protected void doStart() throws Exception {
        super.doStart();
        cache = CamelContextHelper.lookup(getCamelContext(), cacheName, LoadingCache.class);
        if (cache == null) {
            if (configuration.isCreateCacheIfNotExist()) {
                cache = getComponent().getOrCreateCache(cacheName, configuration);
            } else {
                throw new IllegalArgumentException(
                        "LoadingCache instance '" + cacheName + "' not found and createCacheIfNotExist is set to false");
            }
        }
    }

    protected void doStart() throws Exception {
        super.doStart();
        cache = CamelContextHelper.lookup(getCamelContext(), cacheName, Cache.class);
        if (cache == null) {
            if (configuration.isCreateCacheIfNotExist()) {
                cache = getComponent().getOrCreateCache(cacheName, configuration);
            } else {
                throw new IllegalArgumentException(
                        "Cache instance '" + cacheName + "' not found and createCacheIfNotExist is set to false");
            }
        }
    }

    public void onInvalidateAll(Message message) {
        Set<?> keys = message.getHeader(CaffeineConstants.KEYS, Set.class);
         
        if (keys == null) {
            cache.invalidateAll();
        } else {
            cache.invalidateAll(keys);
        }

        setResult(message, true, null, null);
    }

    public void onInvalidateAll(Message message) {

        Set<?> keys = message.getHeader(CaffeineConstants.KEYS, Set.class);
         
        if (keys == null) {
            cache.invalidateAll();
        } else {
            cache.invalidateAll(keys);
        }

        setResult(message, true, null, null);
    }

    private Object getKey(final Message message) throws Exception {
        String value = message.getHeader(CaffeineConstants.KEY, String.class);
        if (value == null) {
            value = configuration.getKey();
        }

        if (value == null) {
            throw new CamelExchangeException(
                    "No value provided in header or as default value (" + CaffeineConstants.KEY + ")", message.getExchange());
        }

        return value;
    }

    private Object getKey(final Message message) throws Exception {
        String value;
        value = message.getHeader(CaffeineConstants.KEY, String.class);
        if (value == null) {
            value = configuration.getKey();
        }

        if (value == null) {
            throw new CamelExchangeException(
                    "No value provided in header or as default value (" + CaffeineConstants.KEY + ")", message.getExchange());
        }

        return value;
    }

    private Object getKey(final Message message) throws Exception {
        String value = message.getHeader(CaffeineConstants.KEY, String.class);
        if (value == null) {
            value = configuration.getKey();
        }

        if (value == null) {
            throw new CamelExchangeException(
                    "No value provided in header or as default value (" + CaffeineConstants.KEY + ")", message.getExchange());
        }

        return value;
    }

    protected Boolean omitXmlDeclaration(Message message, Input input) {
        Boolean omitXmlDeclaration = message.getHeader(XmlSignatureConstants.HEADER_OMIT_XML_DECLARATION, Boolean.class);
        if (omitXmlDeclaration == null) {
            omitXmlDeclaration = input.omitXmlDeclaration();
        }
        if (omitXmlDeclaration == null) {
            omitXmlDeclaration = Boolean.FALSE;
        }
        return omitXmlDeclaration;
    }

    private Object getKey(final Message message) throws Exception {
        String value;
        value = message.getHeader(CaffeineConstants.KEY, String.class);
        if (value == null) {
            value = configuration.getKey();
        }

        if (value == null) {
            throw new CamelExchangeException(
                    "No value provided in header or as default value (" + CaffeineConstants.KEY + ")", message.getExchange());
        }

        return value;
    }

    protected Boolean omitXmlDeclaration(Message message, Input input) {
        Boolean omitXmlDeclaration = message.getHeader(XmlSignatureConstants.HEADER_OMIT_XML_DECLARATION, Boolean.class);
        if (omitXmlDeclaration == null) {
            omitXmlDeclaration = input.omitXmlDeclaration();
        }
        if (omitXmlDeclaration == null) {
            omitXmlDeclaration = Boolean.FALSE;
        }
        return omitXmlDeclaration;
    }

    private Object getValue(final Message message, final String type) throws Exception {
        Object value = message.getHeader(CaffeineConstants.VALUE);
        if (value == null) {
            if (type != null) {
                Class<?> clazz = getEndpoint().getCamelContext().getClassResolver().resolveClass(type);
                value = message.getBody(clazz);
            } else {
                value = message.getBody();
            }
        }

        if (value == null) {
            throw new CamelExchangeException(
                    "No value provided in header or body (" + CaffeineConstants.VALUE + ")", message.getExchange());
        }

        return value;
    }

    private Object getValue(final Message message, final String type) throws Exception {
        Object value = message.getHeader(CaffeineConstants.VALUE);
        if (value == null) {
            if (type != null) {
                Class<?> clazz = getEndpoint().getCamelContext().getClassResolver().resolveClass(type);
                value = message.getBody(clazz);
            } else {
                value = message.getBody();
            }
        }

        if (value == null) {
            throw new CamelExchangeException(
                    "No value provided in header or body (" + CaffeineConstants.VALUE + ")", message.getExchange());
        }

        return value;
    }

    private void setResult(Message message, boolean success, Object result, Object oldValue) {
        message.setHeader(CaffeineConstants.ACTION_SUCCEEDED, success);
        message.setHeader(CaffeineConstants.ACTION_HAS_RESULT, oldValue != null || result != null);

        if (oldValue != null) {
            message.setHeader(CaffeineConstants.OLD_VALUE, oldValue);
        }
        if (result != null) {
            message.setBody(result);
        }
    }

    private void setResult(Message message, boolean success, Object result, Object oldValue) {
        message.setHeader(EhcacheConstants.ACTION_SUCCEEDED, success);
        message.setHeader(EhcacheConstants.ACTION_HAS_RESULT, oldValue != null || result != null);

        if (oldValue != null) {
            message.setHeader(EhcacheConstants.OLD_VALUE, oldValue);
        }
        if (result != null) {
            message.setBody(result);
        }
    }

    private void setResult(Message message, boolean success, Object result, Object oldValue) {
        message.setHeader(CaffeineConstants.ACTION_SUCCEEDED, success);
        message.setHeader(CaffeineConstants.ACTION_HAS_RESULT, oldValue != null || result != null);

        if (oldValue != null) {
            message.setHeader(CaffeineConstants.OLD_VALUE, oldValue);
        }
        if (result != null) {
            message.setBody(result);
        }
    }

    private void setResult(Message message, boolean success, Object result, Object oldValue) {
        message.setHeader(CaffeineConstants.ACTION_SUCCEEDED, success);
        message.setHeader(CaffeineConstants.ACTION_HAS_RESULT, oldValue != null || result != null);

        if (oldValue != null) {
            message.setHeader(CaffeineConstants.OLD_VALUE, oldValue);
        }
        if (result != null) {
            message.setBody(result);
        }
    }

    private void setResult(Message message, boolean success, Object result, Object oldValue) {
        message.setHeader(EhcacheConstants.ACTION_SUCCEEDED, success);
        message.setHeader(EhcacheConstants.ACTION_HAS_RESULT, oldValue != null || result != null);

        if (oldValue != null) {
            message.setHeader(EhcacheConstants.OLD_VALUE, oldValue);
        }
        if (result != null) {
            message.setBody(result);
        }
    }

    private void setResult(Message message, boolean success, Object result, Object oldValue) {
        message.setHeader(CaffeineConstants.ACTION_SUCCEEDED, success);
        message.setHeader(CaffeineConstants.ACTION_HAS_RESULT, oldValue != null || result != null);

        if (oldValue != null) {
            message.setHeader(CaffeineConstants.OLD_VALUE, oldValue);
        }
        if (result != null) {
            message.setBody(result);
        }
    }

    protected void doStart() throws Exception {
        if (maximumRedeliveries < 0) {
            throw new IllegalArgumentException("Maximum redelivery retries must be zero or a positive integer.");
        }
        if (recoveryInterval < 0) {
            throw new IllegalArgumentException("Recovery interval must be zero or a positive integer.");
        }

        if (cache == null) {
            Caffeine<Object, Object> builder = Caffeine.newBuilder();
            cache = builder.build();
        }
    }

    protected void doStart() throws Exception {
        if (maximumRedeliveries < 0) {
            throw new IllegalArgumentException("Maximum redelivery retries must be zero or a positive integer.");
        }
        if (recoveryInterval < 0) {
            throw new IllegalArgumentException("Recovery interval must be zero or a positive integer.");
        }

        if (cache == null) {
            ObjectHelper.notNull(cacheManager, "cacheManager");
            cache = cacheManager.getCache(cacheName, String.class, DefaultExchangeHolder.class);
        }
    }

    public static EvictionType getEvictionType(String name) {
        if (name == null) {
            return null;
        }
        for (EvictionType evictionType : VALUES) {
            if (evictionType.toString().equalsIgnoreCase(name) || evictionType.name().equalsIgnoreCase(name)) {
                return evictionType;
            }
        }
        throw new IllegalArgumentException(String.format("Eviction type '%s' is not supported by this component.", name));
    }

    public static HazelcastQueueConsumerMode getHazelcastOperation(String name) {
        if (name == null) {
            return null;
        }
        for (HazelcastQueueConsumerMode hazelcastQueueConsumerMode : VALUES) {
            if (hazelcastQueueConsumerMode.toString().equalsIgnoreCase(name)
                    || hazelcastQueueConsumerMode.name().equalsIgnoreCase(name)) {
                return hazelcastQueueConsumerMode;
            }
        }
        throw new IllegalArgumentException(String.format("Mode '%s' is not supported by this component.", name));
    }

    public static EvictionType getEvictionType(String name) {
        if (name == null) {
            return null;
        }
        for (EvictionType evictionType : VALUES) {
            if (evictionType.toString().equalsIgnoreCase(name) || evictionType.name().equalsIgnoreCase(name)) {
                return evictionType;
            }
        }
        throw new IllegalArgumentException(String.format("Eviction type '%s' is not supported by this component.", name));
    }

    public static HazelcastOperation getHazelcastOperation(String name) {
        if (name == null) {
            return null;
        }
        for (HazelcastOperation hazelcastOperation : VALUES) {
            if (hazelcastOperation.toString().equalsIgnoreCase(name) || hazelcastOperation.name().equalsIgnoreCase(name)) {
                return hazelcastOperation;
            }
        }
        throw new IllegalArgumentException(String.format("Operation '%s' is not supported by this component.", name));
    }

    public static HazelcastQueueConsumerMode getHazelcastOperation(String name) {
        if (name == null) {
            return null;
        }
        for (HazelcastQueueConsumerMode hazelcastQueueConsumerMode : VALUES) {
            if (hazelcastQueueConsumerMode.toString().equalsIgnoreCase(name)
                    || hazelcastQueueConsumerMode.name().equalsIgnoreCase(name)) {
                return hazelcastQueueConsumerMode;
            }
        }
        throw new IllegalArgumentException(String.format("Mode '%s' is not supported by this component.", name));
    }

    public static HazelcastOperation getHazelcastOperation(String name) {
        if (name == null) {
            return null;
        }
        for (HazelcastOperation hazelcastOperation : VALUES) {
            if (hazelcastOperation.toString().equalsIgnoreCase(name) || hazelcastOperation.name().equalsIgnoreCase(name)) {
                return hazelcastOperation;
            }
        }
        throw new IllegalArgumentException(String.format("Operation '%s' is not supported by this component.", name));
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.caffeine.load.CaffeineLoadCacheProducer target = (org.apache.camel.component.caffeine.load.CaffeineLoadCacheProducer) obj;
        switch (key) {
        case "as_map":
        case "AS_MAP": target.onAsMap(exchange.getMessage()); return null;
        case "cleanup":
        case "CLEANUP": target.onCleanUp(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "invalidate":
        case "INVALIDATE": target.onInvalidate(exchange.getMessage()); return null;
        case "invalidate_all":
        case "INVALIDATE_ALL": target.onInvalidateAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulCatalogProducer target = (org.apache.camel.component.consul.endpoint.ConsulCatalogProducer) obj;
        switch (key) {
        case "deregister":
        case "DEREGISTER": target.deregister(exchange.getMessage()); return null;
        case "get_node":
        case "GET_NODE": target.getNode(exchange.getMessage()); return null;
        case "get_service":
        case "GET_SERVICE": target.getService(exchange.getMessage()); return null;
        case "list_datacenters":
        case "LIST_DATACENTERS": target.listDatacenters(exchange.getMessage()); return null;
        case "list_nodes":
        case "LIST_NODES": target.listNodes(exchange.getMessage()); return null;
        case "list_services":
        case "LIST_SERVICES": target.listServices(exchange.getMessage()); return null;
        case "register":
        case "REGISTER": target.register(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.caffeine.load.CaffeineLoadCacheProducer target = (org.apache.camel.component.caffeine.load.CaffeineLoadCacheProducer) obj;
        switch (key) {
        case "as_map":
        case "AS_MAP": target.onAsMap(exchange.getMessage()); return null;
        case "cleanup":
        case "CLEANUP": target.onCleanUp(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "invalidate":
        case "INVALIDATE": target.onInvalidate(exchange.getMessage()); return null;
        case "invalidate_all":
        case "INVALIDATE_ALL": target.onInvalidateAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.caffeine.cache.CaffeineCacheProducer target = (org.apache.camel.component.caffeine.cache.CaffeineCacheProducer) obj;
        switch (key) {
        case "as_map":
        case "AS_MAP": target.onAsMap(exchange.getMessage()); return null;
        case "cleanup":
        case "CLEANUP": target.onCleanUp(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "invalidate":
        case "INVALIDATE": target.onInvalidate(exchange.getMessage()); return null;
        case "invalidate_all":
        case "INVALIDATE_ALL": target.onInvalidateAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.caffeine.load.CaffeineLoadCacheProducer target = (org.apache.camel.component.caffeine.load.CaffeineLoadCacheProducer) obj;
        switch (key) {
        case "as_map":
        case "AS_MAP": target.onAsMap(exchange.getMessage()); return null;
        case "cleanup":
        case "CLEANUP": target.onCleanUp(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "invalidate":
        case "INVALIDATE": target.onInvalidate(exchange.getMessage()); return null;
        case "invalidate_all":
        case "INVALIDATE_ALL": target.onInvalidateAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulKeyValueProducer target = (org.apache.camel.component.consul.endpoint.ConsulKeyValueProducer) obj;
        switch (key) {
        case "delete_key":
        case "DELETE_KEY": target.deleteKey(exchange.getMessage()); return null;
        case "delete_keys":
        case "DELETE_KEYS": target.deleteKeys(exchange.getMessage()); return null;
        case "get_keys":
        case "GET_KEYS": target.getKeys(exchange.getMessage()); return null;
        case "get_sessions":
        case "GET_SESSIONS": target.getSessions(exchange.getMessage()); return null;
        case "get_value":
        case "GET_VALUE": target.getValue(exchange.getMessage()); return null;
        case "get_values":
        case "GET_VALUES": target.getValues(exchange.getMessage()); return null;
        case "lock":
        case "LOCK": target.lock(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.put(exchange.getMessage()); return null;
        case "unlock":
        case "UNLOCK": target.unlock(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.caffeine.load.CaffeineLoadCacheProducer target = (org.apache.camel.component.caffeine.load.CaffeineLoadCacheProducer) obj;
        switch (key) {
        case "as_map":
        case "AS_MAP": target.onAsMap(exchange.getMessage()); return null;
        case "cleanup":
        case "CLEANUP": target.onCleanUp(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "invalidate":
        case "INVALIDATE": target.onInvalidate(exchange.getMessage()); return null;
        case "invalidate_all":
        case "INVALIDATE_ALL": target.onInvalidateAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.ehcache.EhcacheProducer target = (org.apache.camel.component.ehcache.EhcacheProducer) obj;
        switch (key) {
        case "clear":
        case "CLEAR": target.onClear(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        case "put_if_absent":
        case "PUT_IF_ABSENT": target.onPutIfAbsent(exchange.getMessage()); return null;
        case "remove":
        case "REMOVE": target.onRemove(exchange.getMessage()); return null;
        case "remove_all":
        case "REMOVE_ALL": target.onRemoveAll(exchange.getMessage()); return null;
        case "replace":
        case "REPLACE": target.onReplace(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.caffeine.load.CaffeineLoadCacheProducer target = (org.apache.camel.component.caffeine.load.CaffeineLoadCacheProducer) obj;
        switch (key) {
        case "as_map":
        case "AS_MAP": target.onAsMap(exchange.getMessage()); return null;
        case "cleanup":
        case "CLEANUP": target.onCleanUp(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "invalidate":
        case "INVALIDATE": target.onInvalidate(exchange.getMessage()); return null;
        case "invalidate_all":
        case "INVALIDATE_ALL": target.onInvalidateAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulSessionProducer target = (org.apache.camel.component.consul.endpoint.ConsulSessionProducer) obj;
        switch (key) {
        case "create":
        case "CREATE": target.create(exchange.getMessage()); return null;
        case "destroy":
        case "DESTROY": target.destroy(exchange.getMessage()); return null;
        case "info":
        case "INFO": target.info(exchange.getMessage()); return null;
        case "list":
        case "LIST": target.list(exchange.getMessage()); return null;
        case "renew":
        case "RENEW": target.renew(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.caffeine.load.CaffeineLoadCacheProducer target = (org.apache.camel.component.caffeine.load.CaffeineLoadCacheProducer) obj;
        switch (key) {
        case "as_map":
        case "AS_MAP": target.onAsMap(exchange.getMessage()); return null;
        case "cleanup":
        case "CLEANUP": target.onCleanUp(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "invalidate":
        case "INVALIDATE": target.onInvalidate(exchange.getMessage()); return null;
        case "invalidate_all":
        case "INVALIDATE_ALL": target.onInvalidateAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulAgentProducer target = (org.apache.camel.component.consul.endpoint.ConsulAgentProducer) obj;
        switch (key) {
        case "agent":
        case "AGENT": return target.invokeAgent(exchange.getMessage());
        case "checks":
        case "CHECKS": return target.invokeChecks(exchange.getMessage());
        case "deregister":
        case "DEREGISTER": target.invokeDeregister(exchange.getMessage()); return null;
        case "members":
        case "MEMBERS": return target.invokeMembers(exchange.getMessage());
        case "register":
        case "REGISTER": target.invokeRegister(exchange.getMessage()); return null;
        case "services":
        case "SERVICES": return target.invokeServices(exchange.getMessage());
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.caffeine.load.CaffeineLoadCacheProducer target = (org.apache.camel.component.caffeine.load.CaffeineLoadCacheProducer) obj;
        switch (key) {
        case "as_map":
        case "AS_MAP": target.onAsMap(exchange.getMessage()); return null;
        case "cleanup":
        case "CLEANUP": target.onCleanUp(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "invalidate":
        case "INVALIDATE": target.onInvalidate(exchange.getMessage()); return null;
        case "invalidate_all":
        case "INVALIDATE_ALL": target.onInvalidateAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulHealthProducer target = (org.apache.camel.component.consul.endpoint.ConsulHealthProducer) obj;
        switch (key) {
        case "checks":
        case "CHECKS": target.checks(exchange.getMessage()); return null;
        case "node_checks":
        case "NODE_CHECKS": target.nodeChecks(exchange.getMessage()); return null;
        case "service_checks":
        case "SERVICE_CHECKS": target.serviceChecks(exchange.getMessage()); return null;
        case "service_instances":
        case "SERVICE_INSTANCES": target.serviceInstances(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.caffeine.load.CaffeineLoadCacheProducer target = (org.apache.camel.component.caffeine.load.CaffeineLoadCacheProducer) obj;
        switch (key) {
        case "as_map":
        case "AS_MAP": target.onAsMap(exchange.getMessage()); return null;
        case "cleanup":
        case "CLEANUP": target.onCleanUp(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "invalidate":
        case "INVALIDATE": target.onInvalidate(exchange.getMessage()); return null;
        case "invalidate_all":
        case "INVALIDATE_ALL": target.onInvalidateAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulPreparedQueryProducer target = (org.apache.camel.component.consul.endpoint.ConsulPreparedQueryProducer) obj;
        switch (key) {
        case "create":
        case "CREATE": target.create(exchange.getMessage()); return null;
        case "execute":
        case "EXECUTE": target.execute(exchange.getMessage()); return null;
        case "get":
        case "GET": target.get(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.caffeine.load.CaffeineLoadCacheProducer target = (org.apache.camel.component.caffeine.load.CaffeineLoadCacheProducer) obj;
        switch (key) {
        case "as_map":
        case "AS_MAP": target.onAsMap(exchange.getMessage()); return null;
        case "cleanup":
        case "CLEANUP": target.onCleanUp(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "invalidate":
        case "INVALIDATE": target.onInvalidate(exchange.getMessage()); return null;
        case "invalidate_all":
        case "INVALIDATE_ALL": target.onInvalidateAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.infinispan.remote.InfinispanRemoteProducer target = (org.apache.camel.component.infinispan.remote.InfinispanRemoteProducer) obj;
        switch (key) {
        case "query":
        case "QUERY": target.onQuery(exchange.getMessage()); return null;
        case "stats":
        case "STATS": target.onStats(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.caffeine.load.CaffeineLoadCacheProducer target = (org.apache.camel.component.caffeine.load.CaffeineLoadCacheProducer) obj;
        switch (key) {
        case "as_map":
        case "AS_MAP": target.onAsMap(exchange.getMessage()); return null;
        case "cleanup":
        case "CLEANUP": target.onCleanUp(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "invalidate":
        case "INVALIDATE": target.onInvalidate(exchange.getMessage()); return null;
        case "invalidate_all":
        case "INVALIDATE_ALL": target.onInvalidateAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.infinispan.embedded.InfinispanEmbeddedProducer target = (org.apache.camel.component.infinispan.embedded.InfinispanEmbeddedProducer) obj;
        switch (key) {
        case "query":
        case "QUERY": target.onQuery(exchange.getMessage()); return null;
        case "stats":
        case "STATS": target.onStats(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.caffeine.load.CaffeineLoadCacheProducer target = (org.apache.camel.component.caffeine.load.CaffeineLoadCacheProducer) obj;
        switch (key) {
        case "as_map":
        case "AS_MAP": target.onAsMap(exchange.getMessage()); return null;
        case "cleanup":
        case "CLEANUP": target.onCleanUp(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "invalidate":
        case "INVALIDATE": target.onInvalidate(exchange.getMessage()); return null;
        case "invalidate_all":
        case "INVALIDATE_ALL": target.onInvalidateAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulEventProducer target = (org.apache.camel.component.consul.endpoint.ConsulEventProducer) obj;
        switch (key) {
        case "fire":
        case "FIRE": target.fire(exchange.getMessage()); return null;
        case "list":
        case "LIST": target.list(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.caffeine.load.CaffeineLoadCacheProducer target = (org.apache.camel.component.caffeine.load.CaffeineLoadCacheProducer) obj;
        switch (key) {
        case "as_map":
        case "AS_MAP": target.onAsMap(exchange.getMessage()); return null;
        case "cleanup":
        case "CLEANUP": target.onCleanUp(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "invalidate":
        case "INVALIDATE": target.onInvalidate(exchange.getMessage()); return null;
        case "invalidate_all":
        case "INVALIDATE_ALL": target.onInvalidateAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulCoordinatesProducer target = (org.apache.camel.component.consul.endpoint.ConsulCoordinatesProducer) obj;
        switch (key) {
        case "datacenters":
        case "DATACENTERS": target.datacenters(exchange.getMessage()); return null;
        case "nodes":
        case "NODES": target.nodes(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulCatalogProducer target = (org.apache.camel.component.consul.endpoint.ConsulCatalogProducer) obj;
        switch (key) {
        case "deregister":
        case "DEREGISTER": target.deregister(exchange.getMessage()); return null;
        case "get_node":
        case "GET_NODE": target.getNode(exchange.getMessage()); return null;
        case "get_service":
        case "GET_SERVICE": target.getService(exchange.getMessage()); return null;
        case "list_datacenters":
        case "LIST_DATACENTERS": target.listDatacenters(exchange.getMessage()); return null;
        case "list_nodes":
        case "LIST_NODES": target.listNodes(exchange.getMessage()); return null;
        case "list_services":
        case "LIST_SERVICES": target.listServices(exchange.getMessage()); return null;
        case "register":
        case "REGISTER": target.register(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.caffeine.cache.CaffeineCacheProducer target = (org.apache.camel.component.caffeine.cache.CaffeineCacheProducer) obj;
        switch (key) {
        case "as_map":
        case "AS_MAP": target.onAsMap(exchange.getMessage()); return null;
        case "cleanup":
        case "CLEANUP": target.onCleanUp(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "invalidate":
        case "INVALIDATE": target.onInvalidate(exchange.getMessage()); return null;
        case "invalidate_all":
        case "INVALIDATE_ALL": target.onInvalidateAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulCatalogProducer target = (org.apache.camel.component.consul.endpoint.ConsulCatalogProducer) obj;
        switch (key) {
        case "deregister":
        case "DEREGISTER": target.deregister(exchange.getMessage()); return null;
        case "get_node":
        case "GET_NODE": target.getNode(exchange.getMessage()); return null;
        case "get_service":
        case "GET_SERVICE": target.getService(exchange.getMessage()); return null;
        case "list_datacenters":
        case "LIST_DATACENTERS": target.listDatacenters(exchange.getMessage()); return null;
        case "list_nodes":
        case "LIST_NODES": target.listNodes(exchange.getMessage()); return null;
        case "list_services":
        case "LIST_SERVICES": target.listServices(exchange.getMessage()); return null;
        case "register":
        case "REGISTER": target.register(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulKeyValueProducer target = (org.apache.camel.component.consul.endpoint.ConsulKeyValueProducer) obj;
        switch (key) {
        case "delete_key":
        case "DELETE_KEY": target.deleteKey(exchange.getMessage()); return null;
        case "delete_keys":
        case "DELETE_KEYS": target.deleteKeys(exchange.getMessage()); return null;
        case "get_keys":
        case "GET_KEYS": target.getKeys(exchange.getMessage()); return null;
        case "get_sessions":
        case "GET_SESSIONS": target.getSessions(exchange.getMessage()); return null;
        case "get_value":
        case "GET_VALUE": target.getValue(exchange.getMessage()); return null;
        case "get_values":
        case "GET_VALUES": target.getValues(exchange.getMessage()); return null;
        case "lock":
        case "LOCK": target.lock(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.put(exchange.getMessage()); return null;
        case "unlock":
        case "UNLOCK": target.unlock(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulCatalogProducer target = (org.apache.camel.component.consul.endpoint.ConsulCatalogProducer) obj;
        switch (key) {
        case "deregister":
        case "DEREGISTER": target.deregister(exchange.getMessage()); return null;
        case "get_node":
        case "GET_NODE": target.getNode(exchange.getMessage()); return null;
        case "get_service":
        case "GET_SERVICE": target.getService(exchange.getMessage()); return null;
        case "list_datacenters":
        case "LIST_DATACENTERS": target.listDatacenters(exchange.getMessage()); return null;
        case "list_nodes":
        case "LIST_NODES": target.listNodes(exchange.getMessage()); return null;
        case "list_services":
        case "LIST_SERVICES": target.listServices(exchange.getMessage()); return null;
        case "register":
        case "REGISTER": target.register(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.ehcache.EhcacheProducer target = (org.apache.camel.component.ehcache.EhcacheProducer) obj;
        switch (key) {
        case "clear":
        case "CLEAR": target.onClear(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        case "put_if_absent":
        case "PUT_IF_ABSENT": target.onPutIfAbsent(exchange.getMessage()); return null;
        case "remove":
        case "REMOVE": target.onRemove(exchange.getMessage()); return null;
        case "remove_all":
        case "REMOVE_ALL": target.onRemoveAll(exchange.getMessage()); return null;
        case "replace":
        case "REPLACE": target.onReplace(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulCatalogProducer target = (org.apache.camel.component.consul.endpoint.ConsulCatalogProducer) obj;
        switch (key) {
        case "deregister":
        case "DEREGISTER": target.deregister(exchange.getMessage()); return null;
        case "get_node":
        case "GET_NODE": target.getNode(exchange.getMessage()); return null;
        case "get_service":
        case "GET_SERVICE": target.getService(exchange.getMessage()); return null;
        case "list_datacenters":
        case "LIST_DATACENTERS": target.listDatacenters(exchange.getMessage()); return null;
        case "list_nodes":
        case "LIST_NODES": target.listNodes(exchange.getMessage()); return null;
        case "list_services":
        case "LIST_SERVICES": target.listServices(exchange.getMessage()); return null;
        case "register":
        case "REGISTER": target.register(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulSessionProducer target = (org.apache.camel.component.consul.endpoint.ConsulSessionProducer) obj;
        switch (key) {
        case "create":
        case "CREATE": target.create(exchange.getMessage()); return null;
        case "destroy":
        case "DESTROY": target.destroy(exchange.getMessage()); return null;
        case "info":
        case "INFO": target.info(exchange.getMessage()); return null;
        case "list":
        case "LIST": target.list(exchange.getMessage()); return null;
        case "renew":
        case "RENEW": target.renew(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulCatalogProducer target = (org.apache.camel.component.consul.endpoint.ConsulCatalogProducer) obj;
        switch (key) {
        case "deregister":
        case "DEREGISTER": target.deregister(exchange.getMessage()); return null;
        case "get_node":
        case "GET_NODE": target.getNode(exchange.getMessage()); return null;
        case "get_service":
        case "GET_SERVICE": target.getService(exchange.getMessage()); return null;
        case "list_datacenters":
        case "LIST_DATACENTERS": target.listDatacenters(exchange.getMessage()); return null;
        case "list_nodes":
        case "LIST_NODES": target.listNodes(exchange.getMessage()); return null;
        case "list_services":
        case "LIST_SERVICES": target.listServices(exchange.getMessage()); return null;
        case "register":
        case "REGISTER": target.register(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulAgentProducer target = (org.apache.camel.component.consul.endpoint.ConsulAgentProducer) obj;
        switch (key) {
        case "agent":
        case "AGENT": return target.invokeAgent(exchange.getMessage());
        case "checks":
        case "CHECKS": return target.invokeChecks(exchange.getMessage());
        case "deregister":
        case "DEREGISTER": target.invokeDeregister(exchange.getMessage()); return null;
        case "members":
        case "MEMBERS": return target.invokeMembers(exchange.getMessage());
        case "register":
        case "REGISTER": target.invokeRegister(exchange.getMessage()); return null;
        case "services":
        case "SERVICES": return target.invokeServices(exchange.getMessage());
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulCatalogProducer target = (org.apache.camel.component.consul.endpoint.ConsulCatalogProducer) obj;
        switch (key) {
        case "deregister":
        case "DEREGISTER": target.deregister(exchange.getMessage()); return null;
        case "get_node":
        case "GET_NODE": target.getNode(exchange.getMessage()); return null;
        case "get_service":
        case "GET_SERVICE": target.getService(exchange.getMessage()); return null;
        case "list_datacenters":
        case "LIST_DATACENTERS": target.listDatacenters(exchange.getMessage()); return null;
        case "list_nodes":
        case "LIST_NODES": target.listNodes(exchange.getMessage()); return null;
        case "list_services":
        case "LIST_SERVICES": target.listServices(exchange.getMessage()); return null;
        case "register":
        case "REGISTER": target.register(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulHealthProducer target = (org.apache.camel.component.consul.endpoint.ConsulHealthProducer) obj;
        switch (key) {
        case "checks":
        case "CHECKS": target.checks(exchange.getMessage()); return null;
        case "node_checks":
        case "NODE_CHECKS": target.nodeChecks(exchange.getMessage()); return null;
        case "service_checks":
        case "SERVICE_CHECKS": target.serviceChecks(exchange.getMessage()); return null;
        case "service_instances":
        case "SERVICE_INSTANCES": target.serviceInstances(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulCatalogProducer target = (org.apache.camel.component.consul.endpoint.ConsulCatalogProducer) obj;
        switch (key) {
        case "deregister":
        case "DEREGISTER": target.deregister(exchange.getMessage()); return null;
        case "get_node":
        case "GET_NODE": target.getNode(exchange.getMessage()); return null;
        case "get_service":
        case "GET_SERVICE": target.getService(exchange.getMessage()); return null;
        case "list_datacenters":
        case "LIST_DATACENTERS": target.listDatacenters(exchange.getMessage()); return null;
        case "list_nodes":
        case "LIST_NODES": target.listNodes(exchange.getMessage()); return null;
        case "list_services":
        case "LIST_SERVICES": target.listServices(exchange.getMessage()); return null;
        case "register":
        case "REGISTER": target.register(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulPreparedQueryProducer target = (org.apache.camel.component.consul.endpoint.ConsulPreparedQueryProducer) obj;
        switch (key) {
        case "create":
        case "CREATE": target.create(exchange.getMessage()); return null;
        case "execute":
        case "EXECUTE": target.execute(exchange.getMessage()); return null;
        case "get":
        case "GET": target.get(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulCatalogProducer target = (org.apache.camel.component.consul.endpoint.ConsulCatalogProducer) obj;
        switch (key) {
        case "deregister":
        case "DEREGISTER": target.deregister(exchange.getMessage()); return null;
        case "get_node":
        case "GET_NODE": target.getNode(exchange.getMessage()); return null;
        case "get_service":
        case "GET_SERVICE": target.getService(exchange.getMessage()); return null;
        case "list_datacenters":
        case "LIST_DATACENTERS": target.listDatacenters(exchange.getMessage()); return null;
        case "list_nodes":
        case "LIST_NODES": target.listNodes(exchange.getMessage()); return null;
        case "list_services":
        case "LIST_SERVICES": target.listServices(exchange.getMessage()); return null;
        case "register":
        case "REGISTER": target.register(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.infinispan.remote.InfinispanRemoteProducer target = (org.apache.camel.component.infinispan.remote.InfinispanRemoteProducer) obj;
        switch (key) {
        case "query":
        case "QUERY": target.onQuery(exchange.getMessage()); return null;
        case "stats":
        case "STATS": target.onStats(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulCatalogProducer target = (org.apache.camel.component.consul.endpoint.ConsulCatalogProducer) obj;
        switch (key) {
        case "deregister":
        case "DEREGISTER": target.deregister(exchange.getMessage()); return null;
        case "get_node":
        case "GET_NODE": target.getNode(exchange.getMessage()); return null;
        case "get_service":
        case "GET_SERVICE": target.getService(exchange.getMessage()); return null;
        case "list_datacenters":
        case "LIST_DATACENTERS": target.listDatacenters(exchange.getMessage()); return null;
        case "list_nodes":
        case "LIST_NODES": target.listNodes(exchange.getMessage()); return null;
        case "list_services":
        case "LIST_SERVICES": target.listServices(exchange.getMessage()); return null;
        case "register":
        case "REGISTER": target.register(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.infinispan.embedded.InfinispanEmbeddedProducer target = (org.apache.camel.component.infinispan.embedded.InfinispanEmbeddedProducer) obj;
        switch (key) {
        case "query":
        case "QUERY": target.onQuery(exchange.getMessage()); return null;
        case "stats":
        case "STATS": target.onStats(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulCatalogProducer target = (org.apache.camel.component.consul.endpoint.ConsulCatalogProducer) obj;
        switch (key) {
        case "deregister":
        case "DEREGISTER": target.deregister(exchange.getMessage()); return null;
        case "get_node":
        case "GET_NODE": target.getNode(exchange.getMessage()); return null;
        case "get_service":
        case "GET_SERVICE": target.getService(exchange.getMessage()); return null;
        case "list_datacenters":
        case "LIST_DATACENTERS": target.listDatacenters(exchange.getMessage()); return null;
        case "list_nodes":
        case "LIST_NODES": target.listNodes(exchange.getMessage()); return null;
        case "list_services":
        case "LIST_SERVICES": target.listServices(exchange.getMessage()); return null;
        case "register":
        case "REGISTER": target.register(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulEventProducer target = (org.apache.camel.component.consul.endpoint.ConsulEventProducer) obj;
        switch (key) {
        case "fire":
        case "FIRE": target.fire(exchange.getMessage()); return null;
        case "list":
        case "LIST": target.list(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulCatalogProducer target = (org.apache.camel.component.consul.endpoint.ConsulCatalogProducer) obj;
        switch (key) {
        case "deregister":
        case "DEREGISTER": target.deregister(exchange.getMessage()); return null;
        case "get_node":
        case "GET_NODE": target.getNode(exchange.getMessage()); return null;
        case "get_service":
        case "GET_SERVICE": target.getService(exchange.getMessage()); return null;
        case "list_datacenters":
        case "LIST_DATACENTERS": target.listDatacenters(exchange.getMessage()); return null;
        case "list_nodes":
        case "LIST_NODES": target.listNodes(exchange.getMessage()); return null;
        case "list_services":
        case "LIST_SERVICES": target.listServices(exchange.getMessage()); return null;
        case "register":
        case "REGISTER": target.register(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulCoordinatesProducer target = (org.apache.camel.component.consul.endpoint.ConsulCoordinatesProducer) obj;
        switch (key) {
        case "datacenters":
        case "DATACENTERS": target.datacenters(exchange.getMessage()); return null;
        case "nodes":
        case "NODES": target.nodes(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.caffeine.cache.CaffeineCacheProducer target = (org.apache.camel.component.caffeine.cache.CaffeineCacheProducer) obj;
        switch (key) {
        case "as_map":
        case "AS_MAP": target.onAsMap(exchange.getMessage()); return null;
        case "cleanup":
        case "CLEANUP": target.onCleanUp(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "invalidate":
        case "INVALIDATE": target.onInvalidate(exchange.getMessage()); return null;
        case "invalidate_all":
        case "INVALIDATE_ALL": target.onInvalidateAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulKeyValueProducer target = (org.apache.camel.component.consul.endpoint.ConsulKeyValueProducer) obj;
        switch (key) {
        case "delete_key":
        case "DELETE_KEY": target.deleteKey(exchange.getMessage()); return null;
        case "delete_keys":
        case "DELETE_KEYS": target.deleteKeys(exchange.getMessage()); return null;
        case "get_keys":
        case "GET_KEYS": target.getKeys(exchange.getMessage()); return null;
        case "get_sessions":
        case "GET_SESSIONS": target.getSessions(exchange.getMessage()); return null;
        case "get_value":
        case "GET_VALUE": target.getValue(exchange.getMessage()); return null;
        case "get_values":
        case "GET_VALUES": target.getValues(exchange.getMessage()); return null;
        case "lock":
        case "LOCK": target.lock(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.put(exchange.getMessage()); return null;
        case "unlock":
        case "UNLOCK": target.unlock(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.caffeine.cache.CaffeineCacheProducer target = (org.apache.camel.component.caffeine.cache.CaffeineCacheProducer) obj;
        switch (key) {
        case "as_map":
        case "AS_MAP": target.onAsMap(exchange.getMessage()); return null;
        case "cleanup":
        case "CLEANUP": target.onCleanUp(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "invalidate":
        case "INVALIDATE": target.onInvalidate(exchange.getMessage()); return null;
        case "invalidate_all":
        case "INVALIDATE_ALL": target.onInvalidateAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.ehcache.EhcacheProducer target = (org.apache.camel.component.ehcache.EhcacheProducer) obj;
        switch (key) {
        case "clear":
        case "CLEAR": target.onClear(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        case "put_if_absent":
        case "PUT_IF_ABSENT": target.onPutIfAbsent(exchange.getMessage()); return null;
        case "remove":
        case "REMOVE": target.onRemove(exchange.getMessage()); return null;
        case "remove_all":
        case "REMOVE_ALL": target.onRemoveAll(exchange.getMessage()); return null;
        case "replace":
        case "REPLACE": target.onReplace(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.caffeine.cache.CaffeineCacheProducer target = (org.apache.camel.component.caffeine.cache.CaffeineCacheProducer) obj;
        switch (key) {
        case "as_map":
        case "AS_MAP": target.onAsMap(exchange.getMessage()); return null;
        case "cleanup":
        case "CLEANUP": target.onCleanUp(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "invalidate":
        case "INVALIDATE": target.onInvalidate(exchange.getMessage()); return null;
        case "invalidate_all":
        case "INVALIDATE_ALL": target.onInvalidateAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulSessionProducer target = (org.apache.camel.component.consul.endpoint.ConsulSessionProducer) obj;
        switch (key) {
        case "create":
        case "CREATE": target.create(exchange.getMessage()); return null;
        case "destroy":
        case "DESTROY": target.destroy(exchange.getMessage()); return null;
        case "info":
        case "INFO": target.info(exchange.getMessage()); return null;
        case "list":
        case "LIST": target.list(exchange.getMessage()); return null;
        case "renew":
        case "RENEW": target.renew(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.caffeine.cache.CaffeineCacheProducer target = (org.apache.camel.component.caffeine.cache.CaffeineCacheProducer) obj;
        switch (key) {
        case "as_map":
        case "AS_MAP": target.onAsMap(exchange.getMessage()); return null;
        case "cleanup":
        case "CLEANUP": target.onCleanUp(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "invalidate":
        case "INVALIDATE": target.onInvalidate(exchange.getMessage()); return null;
        case "invalidate_all":
        case "INVALIDATE_ALL": target.onInvalidateAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulAgentProducer target = (org.apache.camel.component.consul.endpoint.ConsulAgentProducer) obj;
        switch (key) {
        case "agent":
        case "AGENT": return target.invokeAgent(exchange.getMessage());
        case "checks":
        case "CHECKS": return target.invokeChecks(exchange.getMessage());
        case "deregister":
        case "DEREGISTER": target.invokeDeregister(exchange.getMessage()); return null;
        case "members":
        case "MEMBERS": return target.invokeMembers(exchange.getMessage());
        case "register":
        case "REGISTER": target.invokeRegister(exchange.getMessage()); return null;
        case "services":
        case "SERVICES": return target.invokeServices(exchange.getMessage());
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.caffeine.cache.CaffeineCacheProducer target = (org.apache.camel.component.caffeine.cache.CaffeineCacheProducer) obj;
        switch (key) {
        case "as_map":
        case "AS_MAP": target.onAsMap(exchange.getMessage()); return null;
        case "cleanup":
        case "CLEANUP": target.onCleanUp(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "invalidate":
        case "INVALIDATE": target.onInvalidate(exchange.getMessage()); return null;
        case "invalidate_all":
        case "INVALIDATE_ALL": target.onInvalidateAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulHealthProducer target = (org.apache.camel.component.consul.endpoint.ConsulHealthProducer) obj;
        switch (key) {
        case "checks":
        case "CHECKS": target.checks(exchange.getMessage()); return null;
        case "node_checks":
        case "NODE_CHECKS": target.nodeChecks(exchange.getMessage()); return null;
        case "service_checks":
        case "SERVICE_CHECKS": target.serviceChecks(exchange.getMessage()); return null;
        case "service_instances":
        case "SERVICE_INSTANCES": target.serviceInstances(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.caffeine.cache.CaffeineCacheProducer target = (org.apache.camel.component.caffeine.cache.CaffeineCacheProducer) obj;
        switch (key) {
        case "as_map":
        case "AS_MAP": target.onAsMap(exchange.getMessage()); return null;
        case "cleanup":
        case "CLEANUP": target.onCleanUp(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "invalidate":
        case "INVALIDATE": target.onInvalidate(exchange.getMessage()); return null;
        case "invalidate_all":
        case "INVALIDATE_ALL": target.onInvalidateAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulPreparedQueryProducer target = (org.apache.camel.component.consul.endpoint.ConsulPreparedQueryProducer) obj;
        switch (key) {
        case "create":
        case "CREATE": target.create(exchange.getMessage()); return null;
        case "execute":
        case "EXECUTE": target.execute(exchange.getMessage()); return null;
        case "get":
        case "GET": target.get(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.caffeine.cache.CaffeineCacheProducer target = (org.apache.camel.component.caffeine.cache.CaffeineCacheProducer) obj;
        switch (key) {
        case "as_map":
        case "AS_MAP": target.onAsMap(exchange.getMessage()); return null;
        case "cleanup":
        case "CLEANUP": target.onCleanUp(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "invalidate":
        case "INVALIDATE": target.onInvalidate(exchange.getMessage()); return null;
        case "invalidate_all":
        case "INVALIDATE_ALL": target.onInvalidateAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.infinispan.remote.InfinispanRemoteProducer target = (org.apache.camel.component.infinispan.remote.InfinispanRemoteProducer) obj;
        switch (key) {
        case "query":
        case "QUERY": target.onQuery(exchange.getMessage()); return null;
        case "stats":
        case "STATS": target.onStats(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.caffeine.cache.CaffeineCacheProducer target = (org.apache.camel.component.caffeine.cache.CaffeineCacheProducer) obj;
        switch (key) {
        case "as_map":
        case "AS_MAP": target.onAsMap(exchange.getMessage()); return null;
        case "cleanup":
        case "CLEANUP": target.onCleanUp(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "invalidate":
        case "INVALIDATE": target.onInvalidate(exchange.getMessage()); return null;
        case "invalidate_all":
        case "INVALIDATE_ALL": target.onInvalidateAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.infinispan.embedded.InfinispanEmbeddedProducer target = (org.apache.camel.component.infinispan.embedded.InfinispanEmbeddedProducer) obj;
        switch (key) {
        case "query":
        case "QUERY": target.onQuery(exchange.getMessage()); return null;
        case "stats":
        case "STATS": target.onStats(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.caffeine.cache.CaffeineCacheProducer target = (org.apache.camel.component.caffeine.cache.CaffeineCacheProducer) obj;
        switch (key) {
        case "as_map":
        case "AS_MAP": target.onAsMap(exchange.getMessage()); return null;
        case "cleanup":
        case "CLEANUP": target.onCleanUp(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "invalidate":
        case "INVALIDATE": target.onInvalidate(exchange.getMessage()); return null;
        case "invalidate_all":
        case "INVALIDATE_ALL": target.onInvalidateAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulEventProducer target = (org.apache.camel.component.consul.endpoint.ConsulEventProducer) obj;
        switch (key) {
        case "fire":
        case "FIRE": target.fire(exchange.getMessage()); return null;
        case "list":
        case "LIST": target.list(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.caffeine.cache.CaffeineCacheProducer target = (org.apache.camel.component.caffeine.cache.CaffeineCacheProducer) obj;
        switch (key) {
        case "as_map":
        case "AS_MAP": target.onAsMap(exchange.getMessage()); return null;
        case "cleanup":
        case "CLEANUP": target.onCleanUp(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "invalidate":
        case "INVALIDATE": target.onInvalidate(exchange.getMessage()); return null;
        case "invalidate_all":
        case "INVALIDATE_ALL": target.onInvalidateAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulCoordinatesProducer target = (org.apache.camel.component.consul.endpoint.ConsulCoordinatesProducer) obj;
        switch (key) {
        case "datacenters":
        case "DATACENTERS": target.datacenters(exchange.getMessage()); return null;
        case "nodes":
        case "NODES": target.nodes(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulKeyValueProducer target = (org.apache.camel.component.consul.endpoint.ConsulKeyValueProducer) obj;
        switch (key) {
        case "delete_key":
        case "DELETE_KEY": target.deleteKey(exchange.getMessage()); return null;
        case "delete_keys":
        case "DELETE_KEYS": target.deleteKeys(exchange.getMessage()); return null;
        case "get_keys":
        case "GET_KEYS": target.getKeys(exchange.getMessage()); return null;
        case "get_sessions":
        case "GET_SESSIONS": target.getSessions(exchange.getMessage()); return null;
        case "get_value":
        case "GET_VALUE": target.getValue(exchange.getMessage()); return null;
        case "get_values":
        case "GET_VALUES": target.getValues(exchange.getMessage()); return null;
        case "lock":
        case "LOCK": target.lock(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.put(exchange.getMessage()); return null;
        case "unlock":
        case "UNLOCK": target.unlock(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.ehcache.EhcacheProducer target = (org.apache.camel.component.ehcache.EhcacheProducer) obj;
        switch (key) {
        case "clear":
        case "CLEAR": target.onClear(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        case "put_if_absent":
        case "PUT_IF_ABSENT": target.onPutIfAbsent(exchange.getMessage()); return null;
        case "remove":
        case "REMOVE": target.onRemove(exchange.getMessage()); return null;
        case "remove_all":
        case "REMOVE_ALL": target.onRemoveAll(exchange.getMessage()); return null;
        case "replace":
        case "REPLACE": target.onReplace(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulKeyValueProducer target = (org.apache.camel.component.consul.endpoint.ConsulKeyValueProducer) obj;
        switch (key) {
        case "delete_key":
        case "DELETE_KEY": target.deleteKey(exchange.getMessage()); return null;
        case "delete_keys":
        case "DELETE_KEYS": target.deleteKeys(exchange.getMessage()); return null;
        case "get_keys":
        case "GET_KEYS": target.getKeys(exchange.getMessage()); return null;
        case "get_sessions":
        case "GET_SESSIONS": target.getSessions(exchange.getMessage()); return null;
        case "get_value":
        case "GET_VALUE": target.getValue(exchange.getMessage()); return null;
        case "get_values":
        case "GET_VALUES": target.getValues(exchange.getMessage()); return null;
        case "lock":
        case "LOCK": target.lock(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.put(exchange.getMessage()); return null;
        case "unlock":
        case "UNLOCK": target.unlock(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulSessionProducer target = (org.apache.camel.component.consul.endpoint.ConsulSessionProducer) obj;
        switch (key) {
        case "create":
        case "CREATE": target.create(exchange.getMessage()); return null;
        case "destroy":
        case "DESTROY": target.destroy(exchange.getMessage()); return null;
        case "info":
        case "INFO": target.info(exchange.getMessage()); return null;
        case "list":
        case "LIST": target.list(exchange.getMessage()); return null;
        case "renew":
        case "RENEW": target.renew(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulKeyValueProducer target = (org.apache.camel.component.consul.endpoint.ConsulKeyValueProducer) obj;
        switch (key) {
        case "delete_key":
        case "DELETE_KEY": target.deleteKey(exchange.getMessage()); return null;
        case "delete_keys":
        case "DELETE_KEYS": target.deleteKeys(exchange.getMessage()); return null;
        case "get_keys":
        case "GET_KEYS": target.getKeys(exchange.getMessage()); return null;
        case "get_sessions":
        case "GET_SESSIONS": target.getSessions(exchange.getMessage()); return null;
        case "get_value":
        case "GET_VALUE": target.getValue(exchange.getMessage()); return null;
        case "get_values":
        case "GET_VALUES": target.getValues(exchange.getMessage()); return null;
        case "lock":
        case "LOCK": target.lock(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.put(exchange.getMessage()); return null;
        case "unlock":
        case "UNLOCK": target.unlock(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulAgentProducer target = (org.apache.camel.component.consul.endpoint.ConsulAgentProducer) obj;
        switch (key) {
        case "agent":
        case "AGENT": return target.invokeAgent(exchange.getMessage());
        case "checks":
        case "CHECKS": return target.invokeChecks(exchange.getMessage());
        case "deregister":
        case "DEREGISTER": target.invokeDeregister(exchange.getMessage()); return null;
        case "members":
        case "MEMBERS": return target.invokeMembers(exchange.getMessage());
        case "register":
        case "REGISTER": target.invokeRegister(exchange.getMessage()); return null;
        case "services":
        case "SERVICES": return target.invokeServices(exchange.getMessage());
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulKeyValueProducer target = (org.apache.camel.component.consul.endpoint.ConsulKeyValueProducer) obj;
        switch (key) {
        case "delete_key":
        case "DELETE_KEY": target.deleteKey(exchange.getMessage()); return null;
        case "delete_keys":
        case "DELETE_KEYS": target.deleteKeys(exchange.getMessage()); return null;
        case "get_keys":
        case "GET_KEYS": target.getKeys(exchange.getMessage()); return null;
        case "get_sessions":
        case "GET_SESSIONS": target.getSessions(exchange.getMessage()); return null;
        case "get_value":
        case "GET_VALUE": target.getValue(exchange.getMessage()); return null;
        case "get_values":
        case "GET_VALUES": target.getValues(exchange.getMessage()); return null;
        case "lock":
        case "LOCK": target.lock(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.put(exchange.getMessage()); return null;
        case "unlock":
        case "UNLOCK": target.unlock(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulHealthProducer target = (org.apache.camel.component.consul.endpoint.ConsulHealthProducer) obj;
        switch (key) {
        case "checks":
        case "CHECKS": target.checks(exchange.getMessage()); return null;
        case "node_checks":
        case "NODE_CHECKS": target.nodeChecks(exchange.getMessage()); return null;
        case "service_checks":
        case "SERVICE_CHECKS": target.serviceChecks(exchange.getMessage()); return null;
        case "service_instances":
        case "SERVICE_INSTANCES": target.serviceInstances(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulKeyValueProducer target = (org.apache.camel.component.consul.endpoint.ConsulKeyValueProducer) obj;
        switch (key) {
        case "delete_key":
        case "DELETE_KEY": target.deleteKey(exchange.getMessage()); return null;
        case "delete_keys":
        case "DELETE_KEYS": target.deleteKeys(exchange.getMessage()); return null;
        case "get_keys":
        case "GET_KEYS": target.getKeys(exchange.getMessage()); return null;
        case "get_sessions":
        case "GET_SESSIONS": target.getSessions(exchange.getMessage()); return null;
        case "get_value":
        case "GET_VALUE": target.getValue(exchange.getMessage()); return null;
        case "get_values":
        case "GET_VALUES": target.getValues(exchange.getMessage()); return null;
        case "lock":
        case "LOCK": target.lock(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.put(exchange.getMessage()); return null;
        case "unlock":
        case "UNLOCK": target.unlock(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulPreparedQueryProducer target = (org.apache.camel.component.consul.endpoint.ConsulPreparedQueryProducer) obj;
        switch (key) {
        case "create":
        case "CREATE": target.create(exchange.getMessage()); return null;
        case "execute":
        case "EXECUTE": target.execute(exchange.getMessage()); return null;
        case "get":
        case "GET": target.get(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulKeyValueProducer target = (org.apache.camel.component.consul.endpoint.ConsulKeyValueProducer) obj;
        switch (key) {
        case "delete_key":
        case "DELETE_KEY": target.deleteKey(exchange.getMessage()); return null;
        case "delete_keys":
        case "DELETE_KEYS": target.deleteKeys(exchange.getMessage()); return null;
        case "get_keys":
        case "GET_KEYS": target.getKeys(exchange.getMessage()); return null;
        case "get_sessions":
        case "GET_SESSIONS": target.getSessions(exchange.getMessage()); return null;
        case "get_value":
        case "GET_VALUE": target.getValue(exchange.getMessage()); return null;
        case "get_values":
        case "GET_VALUES": target.getValues(exchange.getMessage()); return null;
        case "lock":
        case "LOCK": target.lock(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.put(exchange.getMessage()); return null;
        case "unlock":
        case "UNLOCK": target.unlock(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.infinispan.remote.InfinispanRemoteProducer target = (org.apache.camel.component.infinispan.remote.InfinispanRemoteProducer) obj;
        switch (key) {
        case "query":
        case "QUERY": target.onQuery(exchange.getMessage()); return null;
        case "stats":
        case "STATS": target.onStats(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulKeyValueProducer target = (org.apache.camel.component.consul.endpoint.ConsulKeyValueProducer) obj;
        switch (key) {
        case "delete_key":
        case "DELETE_KEY": target.deleteKey(exchange.getMessage()); return null;
        case "delete_keys":
        case "DELETE_KEYS": target.deleteKeys(exchange.getMessage()); return null;
        case "get_keys":
        case "GET_KEYS": target.getKeys(exchange.getMessage()); return null;
        case "get_sessions":
        case "GET_SESSIONS": target.getSessions(exchange.getMessage()); return null;
        case "get_value":
        case "GET_VALUE": target.getValue(exchange.getMessage()); return null;
        case "get_values":
        case "GET_VALUES": target.getValues(exchange.getMessage()); return null;
        case "lock":
        case "LOCK": target.lock(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.put(exchange.getMessage()); return null;
        case "unlock":
        case "UNLOCK": target.unlock(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.infinispan.embedded.InfinispanEmbeddedProducer target = (org.apache.camel.component.infinispan.embedded.InfinispanEmbeddedProducer) obj;
        switch (key) {
        case "query":
        case "QUERY": target.onQuery(exchange.getMessage()); return null;
        case "stats":
        case "STATS": target.onStats(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulKeyValueProducer target = (org.apache.camel.component.consul.endpoint.ConsulKeyValueProducer) obj;
        switch (key) {
        case "delete_key":
        case "DELETE_KEY": target.deleteKey(exchange.getMessage()); return null;
        case "delete_keys":
        case "DELETE_KEYS": target.deleteKeys(exchange.getMessage()); return null;
        case "get_keys":
        case "GET_KEYS": target.getKeys(exchange.getMessage()); return null;
        case "get_sessions":
        case "GET_SESSIONS": target.getSessions(exchange.getMessage()); return null;
        case "get_value":
        case "GET_VALUE": target.getValue(exchange.getMessage()); return null;
        case "get_values":
        case "GET_VALUES": target.getValues(exchange.getMessage()); return null;
        case "lock":
        case "LOCK": target.lock(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.put(exchange.getMessage()); return null;
        case "unlock":
        case "UNLOCK": target.unlock(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulEventProducer target = (org.apache.camel.component.consul.endpoint.ConsulEventProducer) obj;
        switch (key) {
        case "fire":
        case "FIRE": target.fire(exchange.getMessage()); return null;
        case "list":
        case "LIST": target.list(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulKeyValueProducer target = (org.apache.camel.component.consul.endpoint.ConsulKeyValueProducer) obj;
        switch (key) {
        case "delete_key":
        case "DELETE_KEY": target.deleteKey(exchange.getMessage()); return null;
        case "delete_keys":
        case "DELETE_KEYS": target.deleteKeys(exchange.getMessage()); return null;
        case "get_keys":
        case "GET_KEYS": target.getKeys(exchange.getMessage()); return null;
        case "get_sessions":
        case "GET_SESSIONS": target.getSessions(exchange.getMessage()); return null;
        case "get_value":
        case "GET_VALUE": target.getValue(exchange.getMessage()); return null;
        case "get_values":
        case "GET_VALUES": target.getValues(exchange.getMessage()); return null;
        case "lock":
        case "LOCK": target.lock(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.put(exchange.getMessage()); return null;
        case "unlock":
        case "UNLOCK": target.unlock(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulCoordinatesProducer target = (org.apache.camel.component.consul.endpoint.ConsulCoordinatesProducer) obj;
        switch (key) {
        case "datacenters":
        case "DATACENTERS": target.datacenters(exchange.getMessage()); return null;
        case "nodes":
        case "NODES": target.nodes(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.ehcache.EhcacheProducer target = (org.apache.camel.component.ehcache.EhcacheProducer) obj;
        switch (key) {
        case "clear":
        case "CLEAR": target.onClear(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        case "put_if_absent":
        case "PUT_IF_ABSENT": target.onPutIfAbsent(exchange.getMessage()); return null;
        case "remove":
        case "REMOVE": target.onRemove(exchange.getMessage()); return null;
        case "remove_all":
        case "REMOVE_ALL": target.onRemoveAll(exchange.getMessage()); return null;
        case "replace":
        case "REPLACE": target.onReplace(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulSessionProducer target = (org.apache.camel.component.consul.endpoint.ConsulSessionProducer) obj;
        switch (key) {
        case "create":
        case "CREATE": target.create(exchange.getMessage()); return null;
        case "destroy":
        case "DESTROY": target.destroy(exchange.getMessage()); return null;
        case "info":
        case "INFO": target.info(exchange.getMessage()); return null;
        case "list":
        case "LIST": target.list(exchange.getMessage()); return null;
        case "renew":
        case "RENEW": target.renew(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.ehcache.EhcacheProducer target = (org.apache.camel.component.ehcache.EhcacheProducer) obj;
        switch (key) {
        case "clear":
        case "CLEAR": target.onClear(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        case "put_if_absent":
        case "PUT_IF_ABSENT": target.onPutIfAbsent(exchange.getMessage()); return null;
        case "remove":
        case "REMOVE": target.onRemove(exchange.getMessage()); return null;
        case "remove_all":
        case "REMOVE_ALL": target.onRemoveAll(exchange.getMessage()); return null;
        case "replace":
        case "REPLACE": target.onReplace(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulAgentProducer target = (org.apache.camel.component.consul.endpoint.ConsulAgentProducer) obj;
        switch (key) {
        case "agent":
        case "AGENT": return target.invokeAgent(exchange.getMessage());
        case "checks":
        case "CHECKS": return target.invokeChecks(exchange.getMessage());
        case "deregister":
        case "DEREGISTER": target.invokeDeregister(exchange.getMessage()); return null;
        case "members":
        case "MEMBERS": return target.invokeMembers(exchange.getMessage());
        case "register":
        case "REGISTER": target.invokeRegister(exchange.getMessage()); return null;
        case "services":
        case "SERVICES": return target.invokeServices(exchange.getMessage());
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.ehcache.EhcacheProducer target = (org.apache.camel.component.ehcache.EhcacheProducer) obj;
        switch (key) {
        case "clear":
        case "CLEAR": target.onClear(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        case "put_if_absent":
        case "PUT_IF_ABSENT": target.onPutIfAbsent(exchange.getMessage()); return null;
        case "remove":
        case "REMOVE": target.onRemove(exchange.getMessage()); return null;
        case "remove_all":
        case "REMOVE_ALL": target.onRemoveAll(exchange.getMessage()); return null;
        case "replace":
        case "REPLACE": target.onReplace(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulHealthProducer target = (org.apache.camel.component.consul.endpoint.ConsulHealthProducer) obj;
        switch (key) {
        case "checks":
        case "CHECKS": target.checks(exchange.getMessage()); return null;
        case "node_checks":
        case "NODE_CHECKS": target.nodeChecks(exchange.getMessage()); return null;
        case "service_checks":
        case "SERVICE_CHECKS": target.serviceChecks(exchange.getMessage()); return null;
        case "service_instances":
        case "SERVICE_INSTANCES": target.serviceInstances(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.ehcache.EhcacheProducer target = (org.apache.camel.component.ehcache.EhcacheProducer) obj;
        switch (key) {
        case "clear":
        case "CLEAR": target.onClear(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        case "put_if_absent":
        case "PUT_IF_ABSENT": target.onPutIfAbsent(exchange.getMessage()); return null;
        case "remove":
        case "REMOVE": target.onRemove(exchange.getMessage()); return null;
        case "remove_all":
        case "REMOVE_ALL": target.onRemoveAll(exchange.getMessage()); return null;
        case "replace":
        case "REPLACE": target.onReplace(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulPreparedQueryProducer target = (org.apache.camel.component.consul.endpoint.ConsulPreparedQueryProducer) obj;
        switch (key) {
        case "create":
        case "CREATE": target.create(exchange.getMessage()); return null;
        case "execute":
        case "EXECUTE": target.execute(exchange.getMessage()); return null;
        case "get":
        case "GET": target.get(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.ehcache.EhcacheProducer target = (org.apache.camel.component.ehcache.EhcacheProducer) obj;
        switch (key) {
        case "clear":
        case "CLEAR": target.onClear(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        case "put_if_absent":
        case "PUT_IF_ABSENT": target.onPutIfAbsent(exchange.getMessage()); return null;
        case "remove":
        case "REMOVE": target.onRemove(exchange.getMessage()); return null;
        case "remove_all":
        case "REMOVE_ALL": target.onRemoveAll(exchange.getMessage()); return null;
        case "replace":
        case "REPLACE": target.onReplace(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.infinispan.remote.InfinispanRemoteProducer target = (org.apache.camel.component.infinispan.remote.InfinispanRemoteProducer) obj;
        switch (key) {
        case "query":
        case "QUERY": target.onQuery(exchange.getMessage()); return null;
        case "stats":
        case "STATS": target.onStats(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.ehcache.EhcacheProducer target = (org.apache.camel.component.ehcache.EhcacheProducer) obj;
        switch (key) {
        case "clear":
        case "CLEAR": target.onClear(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        case "put_if_absent":
        case "PUT_IF_ABSENT": target.onPutIfAbsent(exchange.getMessage()); return null;
        case "remove":
        case "REMOVE": target.onRemove(exchange.getMessage()); return null;
        case "remove_all":
        case "REMOVE_ALL": target.onRemoveAll(exchange.getMessage()); return null;
        case "replace":
        case "REPLACE": target.onReplace(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.infinispan.embedded.InfinispanEmbeddedProducer target = (org.apache.camel.component.infinispan.embedded.InfinispanEmbeddedProducer) obj;
        switch (key) {
        case "query":
        case "QUERY": target.onQuery(exchange.getMessage()); return null;
        case "stats":
        case "STATS": target.onStats(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.ehcache.EhcacheProducer target = (org.apache.camel.component.ehcache.EhcacheProducer) obj;
        switch (key) {
        case "clear":
        case "CLEAR": target.onClear(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        case "put_if_absent":
        case "PUT_IF_ABSENT": target.onPutIfAbsent(exchange.getMessage()); return null;
        case "remove":
        case "REMOVE": target.onRemove(exchange.getMessage()); return null;
        case "remove_all":
        case "REMOVE_ALL": target.onRemoveAll(exchange.getMessage()); return null;
        case "replace":
        case "REPLACE": target.onReplace(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulEventProducer target = (org.apache.camel.component.consul.endpoint.ConsulEventProducer) obj;
        switch (key) {
        case "fire":
        case "FIRE": target.fire(exchange.getMessage()); return null;
        case "list":
        case "LIST": target.list(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.ehcache.EhcacheProducer target = (org.apache.camel.component.ehcache.EhcacheProducer) obj;
        switch (key) {
        case "clear":
        case "CLEAR": target.onClear(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        case "put_if_absent":
        case "PUT_IF_ABSENT": target.onPutIfAbsent(exchange.getMessage()); return null;
        case "remove":
        case "REMOVE": target.onRemove(exchange.getMessage()); return null;
        case "remove_all":
        case "REMOVE_ALL": target.onRemoveAll(exchange.getMessage()); return null;
        case "replace":
        case "REPLACE": target.onReplace(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulCoordinatesProducer target = (org.apache.camel.component.consul.endpoint.ConsulCoordinatesProducer) obj;
        switch (key) {
        case "datacenters":
        case "DATACENTERS": target.datacenters(exchange.getMessage()); return null;
        case "nodes":
        case "NODES": target.nodes(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulSessionProducer target = (org.apache.camel.component.consul.endpoint.ConsulSessionProducer) obj;
        switch (key) {
        case "create":
        case "CREATE": target.create(exchange.getMessage()); return null;
        case "destroy":
        case "DESTROY": target.destroy(exchange.getMessage()); return null;
        case "info":
        case "INFO": target.info(exchange.getMessage()); return null;
        case "list":
        case "LIST": target.list(exchange.getMessage()); return null;
        case "renew":
        case "RENEW": target.renew(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulAgentProducer target = (org.apache.camel.component.consul.endpoint.ConsulAgentProducer) obj;
        switch (key) {
        case "agent":
        case "AGENT": return target.invokeAgent(exchange.getMessage());
        case "checks":
        case "CHECKS": return target.invokeChecks(exchange.getMessage());
        case "deregister":
        case "DEREGISTER": target.invokeDeregister(exchange.getMessage()); return null;
        case "members":
        case "MEMBERS": return target.invokeMembers(exchange.getMessage());
        case "register":
        case "REGISTER": target.invokeRegister(exchange.getMessage()); return null;
        case "services":
        case "SERVICES": return target.invokeServices(exchange.getMessage());
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulSessionProducer target = (org.apache.camel.component.consul.endpoint.ConsulSessionProducer) obj;
        switch (key) {
        case "create":
        case "CREATE": target.create(exchange.getMessage()); return null;
        case "destroy":
        case "DESTROY": target.destroy(exchange.getMessage()); return null;
        case "info":
        case "INFO": target.info(exchange.getMessage()); return null;
        case "list":
        case "LIST": target.list(exchange.getMessage()); return null;
        case "renew":
        case "RENEW": target.renew(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulHealthProducer target = (org.apache.camel.component.consul.endpoint.ConsulHealthProducer) obj;
        switch (key) {
        case "checks":
        case "CHECKS": target.checks(exchange.getMessage()); return null;
        case "node_checks":
        case "NODE_CHECKS": target.nodeChecks(exchange.getMessage()); return null;
        case "service_checks":
        case "SERVICE_CHECKS": target.serviceChecks(exchange.getMessage()); return null;
        case "service_instances":
        case "SERVICE_INSTANCES": target.serviceInstances(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulSessionProducer target = (org.apache.camel.component.consul.endpoint.ConsulSessionProducer) obj;
        switch (key) {
        case "create":
        case "CREATE": target.create(exchange.getMessage()); return null;
        case "destroy":
        case "DESTROY": target.destroy(exchange.getMessage()); return null;
        case "info":
        case "INFO": target.info(exchange.getMessage()); return null;
        case "list":
        case "LIST": target.list(exchange.getMessage()); return null;
        case "renew":
        case "RENEW": target.renew(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulPreparedQueryProducer target = (org.apache.camel.component.consul.endpoint.ConsulPreparedQueryProducer) obj;
        switch (key) {
        case "create":
        case "CREATE": target.create(exchange.getMessage()); return null;
        case "execute":
        case "EXECUTE": target.execute(exchange.getMessage()); return null;
        case "get":
        case "GET": target.get(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulSessionProducer target = (org.apache.camel.component.consul.endpoint.ConsulSessionProducer) obj;
        switch (key) {
        case "create":
        case "CREATE": target.create(exchange.getMessage()); return null;
        case "destroy":
        case "DESTROY": target.destroy(exchange.getMessage()); return null;
        case "info":
        case "INFO": target.info(exchange.getMessage()); return null;
        case "list":
        case "LIST": target.list(exchange.getMessage()); return null;
        case "renew":
        case "RENEW": target.renew(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.infinispan.remote.InfinispanRemoteProducer target = (org.apache.camel.component.infinispan.remote.InfinispanRemoteProducer) obj;
        switch (key) {
        case "query":
        case "QUERY": target.onQuery(exchange.getMessage()); return null;
        case "stats":
        case "STATS": target.onStats(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulSessionProducer target = (org.apache.camel.component.consul.endpoint.ConsulSessionProducer) obj;
        switch (key) {
        case "create":
        case "CREATE": target.create(exchange.getMessage()); return null;
        case "destroy":
        case "DESTROY": target.destroy(exchange.getMessage()); return null;
        case "info":
        case "INFO": target.info(exchange.getMessage()); return null;
        case "list":
        case "LIST": target.list(exchange.getMessage()); return null;
        case "renew":
        case "RENEW": target.renew(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.infinispan.embedded.InfinispanEmbeddedProducer target = (org.apache.camel.component.infinispan.embedded.InfinispanEmbeddedProducer) obj;
        switch (key) {
        case "query":
        case "QUERY": target.onQuery(exchange.getMessage()); return null;
        case "stats":
        case "STATS": target.onStats(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulSessionProducer target = (org.apache.camel.component.consul.endpoint.ConsulSessionProducer) obj;
        switch (key) {
        case "create":
        case "CREATE": target.create(exchange.getMessage()); return null;
        case "destroy":
        case "DESTROY": target.destroy(exchange.getMessage()); return null;
        case "info":
        case "INFO": target.info(exchange.getMessage()); return null;
        case "list":
        case "LIST": target.list(exchange.getMessage()); return null;
        case "renew":
        case "RENEW": target.renew(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulEventProducer target = (org.apache.camel.component.consul.endpoint.ConsulEventProducer) obj;
        switch (key) {
        case "fire":
        case "FIRE": target.fire(exchange.getMessage()); return null;
        case "list":
        case "LIST": target.list(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulSessionProducer target = (org.apache.camel.component.consul.endpoint.ConsulSessionProducer) obj;
        switch (key) {
        case "create":
        case "CREATE": target.create(exchange.getMessage()); return null;
        case "destroy":
        case "DESTROY": target.destroy(exchange.getMessage()); return null;
        case "info":
        case "INFO": target.info(exchange.getMessage()); return null;
        case "list":
        case "LIST": target.list(exchange.getMessage()); return null;
        case "renew":
        case "RENEW": target.renew(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulCoordinatesProducer target = (org.apache.camel.component.consul.endpoint.ConsulCoordinatesProducer) obj;
        switch (key) {
        case "datacenters":
        case "DATACENTERS": target.datacenters(exchange.getMessage()); return null;
        case "nodes":
        case "NODES": target.nodes(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulAgentProducer target = (org.apache.camel.component.consul.endpoint.ConsulAgentProducer) obj;
        switch (key) {
        case "agent":
        case "AGENT": return target.invokeAgent(exchange.getMessage());
        case "checks":
        case "CHECKS": return target.invokeChecks(exchange.getMessage());
        case "deregister":
        case "DEREGISTER": target.invokeDeregister(exchange.getMessage()); return null;
        case "members":
        case "MEMBERS": return target.invokeMembers(exchange.getMessage());
        case "register":
        case "REGISTER": target.invokeRegister(exchange.getMessage()); return null;
        case "services":
        case "SERVICES": return target.invokeServices(exchange.getMessage());
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulHealthProducer target = (org.apache.camel.component.consul.endpoint.ConsulHealthProducer) obj;
        switch (key) {
        case "checks":
        case "CHECKS": target.checks(exchange.getMessage()); return null;
        case "node_checks":
        case "NODE_CHECKS": target.nodeChecks(exchange.getMessage()); return null;
        case "service_checks":
        case "SERVICE_CHECKS": target.serviceChecks(exchange.getMessage()); return null;
        case "service_instances":
        case "SERVICE_INSTANCES": target.serviceInstances(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulAgentProducer target = (org.apache.camel.component.consul.endpoint.ConsulAgentProducer) obj;
        switch (key) {
        case "agent":
        case "AGENT": return target.invokeAgent(exchange.getMessage());
        case "checks":
        case "CHECKS": return target.invokeChecks(exchange.getMessage());
        case "deregister":
        case "DEREGISTER": target.invokeDeregister(exchange.getMessage()); return null;
        case "members":
        case "MEMBERS": return target.invokeMembers(exchange.getMessage());
        case "register":
        case "REGISTER": target.invokeRegister(exchange.getMessage()); return null;
        case "services":
        case "SERVICES": return target.invokeServices(exchange.getMessage());
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulPreparedQueryProducer target = (org.apache.camel.component.consul.endpoint.ConsulPreparedQueryProducer) obj;
        switch (key) {
        case "create":
        case "CREATE": target.create(exchange.getMessage()); return null;
        case "execute":
        case "EXECUTE": target.execute(exchange.getMessage()); return null;
        case "get":
        case "GET": target.get(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulAgentProducer target = (org.apache.camel.component.consul.endpoint.ConsulAgentProducer) obj;
        switch (key) {
        case "agent":
        case "AGENT": return target.invokeAgent(exchange.getMessage());
        case "checks":
        case "CHECKS": return target.invokeChecks(exchange.getMessage());
        case "deregister":
        case "DEREGISTER": target.invokeDeregister(exchange.getMessage()); return null;
        case "members":
        case "MEMBERS": return target.invokeMembers(exchange.getMessage());
        case "register":
        case "REGISTER": target.invokeRegister(exchange.getMessage()); return null;
        case "services":
        case "SERVICES": return target.invokeServices(exchange.getMessage());
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.infinispan.remote.InfinispanRemoteProducer target = (org.apache.camel.component.infinispan.remote.InfinispanRemoteProducer) obj;
        switch (key) {
        case "query":
        case "QUERY": target.onQuery(exchange.getMessage()); return null;
        case "stats":
        case "STATS": target.onStats(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulAgentProducer target = (org.apache.camel.component.consul.endpoint.ConsulAgentProducer) obj;
        switch (key) {
        case "agent":
        case "AGENT": return target.invokeAgent(exchange.getMessage());
        case "checks":
        case "CHECKS": return target.invokeChecks(exchange.getMessage());
        case "deregister":
        case "DEREGISTER": target.invokeDeregister(exchange.getMessage()); return null;
        case "members":
        case "MEMBERS": return target.invokeMembers(exchange.getMessage());
        case "register":
        case "REGISTER": target.invokeRegister(exchange.getMessage()); return null;
        case "services":
        case "SERVICES": return target.invokeServices(exchange.getMessage());
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.infinispan.embedded.InfinispanEmbeddedProducer target = (org.apache.camel.component.infinispan.embedded.InfinispanEmbeddedProducer) obj;
        switch (key) {
        case "query":
        case "QUERY": target.onQuery(exchange.getMessage()); return null;
        case "stats":
        case "STATS": target.onStats(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulAgentProducer target = (org.apache.camel.component.consul.endpoint.ConsulAgentProducer) obj;
        switch (key) {
        case "agent":
        case "AGENT": return target.invokeAgent(exchange.getMessage());
        case "checks":
        case "CHECKS": return target.invokeChecks(exchange.getMessage());
        case "deregister":
        case "DEREGISTER": target.invokeDeregister(exchange.getMessage()); return null;
        case "members":
        case "MEMBERS": return target.invokeMembers(exchange.getMessage());
        case "register":
        case "REGISTER": target.invokeRegister(exchange.getMessage()); return null;
        case "services":
        case "SERVICES": return target.invokeServices(exchange.getMessage());
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulEventProducer target = (org.apache.camel.component.consul.endpoint.ConsulEventProducer) obj;
        switch (key) {
        case "fire":
        case "FIRE": target.fire(exchange.getMessage()); return null;
        case "list":
        case "LIST": target.list(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulAgentProducer target = (org.apache.camel.component.consul.endpoint.ConsulAgentProducer) obj;
        switch (key) {
        case "agent":
        case "AGENT": return target.invokeAgent(exchange.getMessage());
        case "checks":
        case "CHECKS": return target.invokeChecks(exchange.getMessage());
        case "deregister":
        case "DEREGISTER": target.invokeDeregister(exchange.getMessage()); return null;
        case "members":
        case "MEMBERS": return target.invokeMembers(exchange.getMessage());
        case "register":
        case "REGISTER": target.invokeRegister(exchange.getMessage()); return null;
        case "services":
        case "SERVICES": return target.invokeServices(exchange.getMessage());
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulCoordinatesProducer target = (org.apache.camel.component.consul.endpoint.ConsulCoordinatesProducer) obj;
        switch (key) {
        case "datacenters":
        case "DATACENTERS": target.datacenters(exchange.getMessage()); return null;
        case "nodes":
        case "NODES": target.nodes(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulHealthProducer target = (org.apache.camel.component.consul.endpoint.ConsulHealthProducer) obj;
        switch (key) {
        case "checks":
        case "CHECKS": target.checks(exchange.getMessage()); return null;
        case "node_checks":
        case "NODE_CHECKS": target.nodeChecks(exchange.getMessage()); return null;
        case "service_checks":
        case "SERVICE_CHECKS": target.serviceChecks(exchange.getMessage()); return null;
        case "service_instances":
        case "SERVICE_INSTANCES": target.serviceInstances(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulPreparedQueryProducer target = (org.apache.camel.component.consul.endpoint.ConsulPreparedQueryProducer) obj;
        switch (key) {
        case "create":
        case "CREATE": target.create(exchange.getMessage()); return null;
        case "execute":
        case "EXECUTE": target.execute(exchange.getMessage()); return null;
        case "get":
        case "GET": target.get(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulHealthProducer target = (org.apache.camel.component.consul.endpoint.ConsulHealthProducer) obj;
        switch (key) {
        case "checks":
        case "CHECKS": target.checks(exchange.getMessage()); return null;
        case "node_checks":
        case "NODE_CHECKS": target.nodeChecks(exchange.getMessage()); return null;
        case "service_checks":
        case "SERVICE_CHECKS": target.serviceChecks(exchange.getMessage()); return null;
        case "service_instances":
        case "SERVICE_INSTANCES": target.serviceInstances(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.infinispan.remote.InfinispanRemoteProducer target = (org.apache.camel.component.infinispan.remote.InfinispanRemoteProducer) obj;
        switch (key) {
        case "query":
        case "QUERY": target.onQuery(exchange.getMessage()); return null;
        case "stats":
        case "STATS": target.onStats(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulHealthProducer target = (org.apache.camel.component.consul.endpoint.ConsulHealthProducer) obj;
        switch (key) {
        case "checks":
        case "CHECKS": target.checks(exchange.getMessage()); return null;
        case "node_checks":
        case "NODE_CHECKS": target.nodeChecks(exchange.getMessage()); return null;
        case "service_checks":
        case "SERVICE_CHECKS": target.serviceChecks(exchange.getMessage()); return null;
        case "service_instances":
        case "SERVICE_INSTANCES": target.serviceInstances(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.infinispan.embedded.InfinispanEmbeddedProducer target = (org.apache.camel.component.infinispan.embedded.InfinispanEmbeddedProducer) obj;
        switch (key) {
        case "query":
        case "QUERY": target.onQuery(exchange.getMessage()); return null;
        case "stats":
        case "STATS": target.onStats(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulHealthProducer target = (org.apache.camel.component.consul.endpoint.ConsulHealthProducer) obj;
        switch (key) {
        case "checks":
        case "CHECKS": target.checks(exchange.getMessage()); return null;
        case "node_checks":
        case "NODE_CHECKS": target.nodeChecks(exchange.getMessage()); return null;
        case "service_checks":
        case "SERVICE_CHECKS": target.serviceChecks(exchange.getMessage()); return null;
        case "service_instances":
        case "SERVICE_INSTANCES": target.serviceInstances(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulEventProducer target = (org.apache.camel.component.consul.endpoint.ConsulEventProducer) obj;
        switch (key) {
        case "fire":
        case "FIRE": target.fire(exchange.getMessage()); return null;
        case "list":
        case "LIST": target.list(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulHealthProducer target = (org.apache.camel.component.consul.endpoint.ConsulHealthProducer) obj;
        switch (key) {
        case "checks":
        case "CHECKS": target.checks(exchange.getMessage()); return null;
        case "node_checks":
        case "NODE_CHECKS": target.nodeChecks(exchange.getMessage()); return null;
        case "service_checks":
        case "SERVICE_CHECKS": target.serviceChecks(exchange.getMessage()); return null;
        case "service_instances":
        case "SERVICE_INSTANCES": target.serviceInstances(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulCoordinatesProducer target = (org.apache.camel.component.consul.endpoint.ConsulCoordinatesProducer) obj;
        switch (key) {
        case "datacenters":
        case "DATACENTERS": target.datacenters(exchange.getMessage()); return null;
        case "nodes":
        case "NODES": target.nodes(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulPreparedQueryProducer target = (org.apache.camel.component.consul.endpoint.ConsulPreparedQueryProducer) obj;
        switch (key) {
        case "create":
        case "CREATE": target.create(exchange.getMessage()); return null;
        case "execute":
        case "EXECUTE": target.execute(exchange.getMessage()); return null;
        case "get":
        case "GET": target.get(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.infinispan.remote.InfinispanRemoteProducer target = (org.apache.camel.component.infinispan.remote.InfinispanRemoteProducer) obj;
        switch (key) {
        case "query":
        case "QUERY": target.onQuery(exchange.getMessage()); return null;
        case "stats":
        case "STATS": target.onStats(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulPreparedQueryProducer target = (org.apache.camel.component.consul.endpoint.ConsulPreparedQueryProducer) obj;
        switch (key) {
        case "create":
        case "CREATE": target.create(exchange.getMessage()); return null;
        case "execute":
        case "EXECUTE": target.execute(exchange.getMessage()); return null;
        case "get":
        case "GET": target.get(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.infinispan.embedded.InfinispanEmbeddedProducer target = (org.apache.camel.component.infinispan.embedded.InfinispanEmbeddedProducer) obj;
        switch (key) {
        case "query":
        case "QUERY": target.onQuery(exchange.getMessage()); return null;
        case "stats":
        case "STATS": target.onStats(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulPreparedQueryProducer target = (org.apache.camel.component.consul.endpoint.ConsulPreparedQueryProducer) obj;
        switch (key) {
        case "create":
        case "CREATE": target.create(exchange.getMessage()); return null;
        case "execute":
        case "EXECUTE": target.execute(exchange.getMessage()); return null;
        case "get":
        case "GET": target.get(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulEventProducer target = (org.apache.camel.component.consul.endpoint.ConsulEventProducer) obj;
        switch (key) {
        case "fire":
        case "FIRE": target.fire(exchange.getMessage()); return null;
        case "list":
        case "LIST": target.list(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulPreparedQueryProducer target = (org.apache.camel.component.consul.endpoint.ConsulPreparedQueryProducer) obj;
        switch (key) {
        case "create":
        case "CREATE": target.create(exchange.getMessage()); return null;
        case "execute":
        case "EXECUTE": target.execute(exchange.getMessage()); return null;
        case "get":
        case "GET": target.get(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulCoordinatesProducer target = (org.apache.camel.component.consul.endpoint.ConsulCoordinatesProducer) obj;
        switch (key) {
        case "datacenters":
        case "DATACENTERS": target.datacenters(exchange.getMessage()); return null;
        case "nodes":
        case "NODES": target.nodes(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.infinispan.remote.InfinispanRemoteProducer target = (org.apache.camel.component.infinispan.remote.InfinispanRemoteProducer) obj;
        switch (key) {
        case "query":
        case "QUERY": target.onQuery(exchange.getMessage()); return null;
        case "stats":
        case "STATS": target.onStats(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.infinispan.embedded.InfinispanEmbeddedProducer target = (org.apache.camel.component.infinispan.embedded.InfinispanEmbeddedProducer) obj;
        switch (key) {
        case "query":
        case "QUERY": target.onQuery(exchange.getMessage()); return null;
        case "stats":
        case "STATS": target.onStats(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.infinispan.remote.InfinispanRemoteProducer target = (org.apache.camel.component.infinispan.remote.InfinispanRemoteProducer) obj;
        switch (key) {
        case "query":
        case "QUERY": target.onQuery(exchange.getMessage()); return null;
        case "stats":
        case "STATS": target.onStats(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulEventProducer target = (org.apache.camel.component.consul.endpoint.ConsulEventProducer) obj;
        switch (key) {
        case "fire":
        case "FIRE": target.fire(exchange.getMessage()); return null;
        case "list":
        case "LIST": target.list(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.infinispan.remote.InfinispanRemoteProducer target = (org.apache.camel.component.infinispan.remote.InfinispanRemoteProducer) obj;
        switch (key) {
        case "query":
        case "QUERY": target.onQuery(exchange.getMessage()); return null;
        case "stats":
        case "STATS": target.onStats(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulCoordinatesProducer target = (org.apache.camel.component.consul.endpoint.ConsulCoordinatesProducer) obj;
        switch (key) {
        case "datacenters":
        case "DATACENTERS": target.datacenters(exchange.getMessage()); return null;
        case "nodes":
        case "NODES": target.nodes(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.infinispan.embedded.InfinispanEmbeddedProducer target = (org.apache.camel.component.infinispan.embedded.InfinispanEmbeddedProducer) obj;
        switch (key) {
        case "query":
        case "QUERY": target.onQuery(exchange.getMessage()); return null;
        case "stats":
        case "STATS": target.onStats(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulEventProducer target = (org.apache.camel.component.consul.endpoint.ConsulEventProducer) obj;
        switch (key) {
        case "fire":
        case "FIRE": target.fire(exchange.getMessage()); return null;
        case "list":
        case "LIST": target.list(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.infinispan.embedded.InfinispanEmbeddedProducer target = (org.apache.camel.component.infinispan.embedded.InfinispanEmbeddedProducer) obj;
        switch (key) {
        case "query":
        case "QUERY": target.onQuery(exchange.getMessage()); return null;
        case "stats":
        case "STATS": target.onStats(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulCoordinatesProducer target = (org.apache.camel.component.consul.endpoint.ConsulCoordinatesProducer) obj;
        switch (key) {
        case "datacenters":
        case "DATACENTERS": target.datacenters(exchange.getMessage()); return null;
        case "nodes":
        case "NODES": target.nodes(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulEventProducer target = (org.apache.camel.component.consul.endpoint.ConsulEventProducer) obj;
        switch (key) {
        case "fire":
        case "FIRE": target.fire(exchange.getMessage()); return null;
        case "list":
        case "LIST": target.list(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulCoordinatesProducer target = (org.apache.camel.component.consul.endpoint.ConsulCoordinatesProducer) obj;
        switch (key) {
        case "datacenters":
        case "DATACENTERS": target.datacenters(exchange.getMessage()); return null;
        case "nodes":
        case "NODES": target.nodes(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public ActiveMQQueueEndpoint(String uri, JmsComponent component, String destination,
                                 JmsConfiguration configuration, QueueBrowseStrategy queueBrowseStrategy) {
        super(uri, component, destination, false, configuration);
        setDestinationType("queue");
        if (queueBrowseStrategy == null) {
            this.queueBrowseStrategy = createQueueBrowseStrategy();
        } else {
            this.queueBrowseStrategy = queueBrowseStrategy;
        }
    }

    public JmsQueueEndpoint(String endpointUri, String destination, QueueBrowseStrategy queueBrowseStrategy) {
        super(endpointUri, destination, false);
        setDestinationType("queue");
        if (queueBrowseStrategy == null) {
            this.queueBrowseStrategy = createQueueBrowseStrategy();
        } else {
            this.queueBrowseStrategy = queueBrowseStrategy;
        }
    }

    public ActiveMQQueueEndpoint(String uri, JmsComponent component, String destination,
                                 JmsConfiguration configuration, QueueBrowseStrategy queueBrowseStrategy) {
        super(uri, component, destination, false, configuration);
        setDestinationType("queue");
        if (queueBrowseStrategy == null) {
            this.queueBrowseStrategy = createQueueBrowseStrategy();
        } else {
            this.queueBrowseStrategy = queueBrowseStrategy;
        }
    }

    public ActiveMQQueueEndpoint(String endpointUri, String destination, QueueBrowseStrategy queueBrowseStrategy) {
        super(endpointUri, destination, false);
        setDestinationType("queue");
        if (queueBrowseStrategy == null) {
            this.queueBrowseStrategy = createQueueBrowseStrategy();
        } else {
            this.queueBrowseStrategy = queueBrowseStrategy;
        }
    }

    public ActiveMQQueueEndpoint(String uri, JmsComponent component, String destination,
                                 JmsConfiguration configuration, QueueBrowseStrategy queueBrowseStrategy) {
        super(uri, component, destination, false, configuration);
        setDestinationType("queue");
        if (queueBrowseStrategy == null) {
            this.queueBrowseStrategy = createQueueBrowseStrategy();
        } else {
            this.queueBrowseStrategy = queueBrowseStrategy;
        }
    }

    public ActiveMQQueueEndpoint(String uri, JmsComponent component, String destination,
                                 JmsConfiguration configuration, QueueBrowseStrategy queueBrowseStrategy) {
        super(uri, component, destination, false, configuration);
        setDestinationType("queue");
        if (queueBrowseStrategy == null) {
            this.queueBrowseStrategy = createQueueBrowseStrategy();
        } else {
            this.queueBrowseStrategy = queueBrowseStrategy;
        }
    }

    public ActiveMQQueueEndpoint(String uri, JmsComponent component, String destination,
                                 JmsConfiguration configuration, QueueBrowseStrategy queueBrowseStrategy) {
        super(uri, component, destination, false, configuration);
        setDestinationType("queue");
        if (queueBrowseStrategy == null) {
            this.queueBrowseStrategy = createQueueBrowseStrategy();
        } else {
            this.queueBrowseStrategy = queueBrowseStrategy;
        }
    }

    public ActiveMQQueueEndpoint(String endpointUri, String destination, QueueBrowseStrategy queueBrowseStrategy) {
        super(endpointUri, destination, false);
        setDestinationType("queue");
        if (queueBrowseStrategy == null) {
            this.queueBrowseStrategy = createQueueBrowseStrategy();
        } else {
            this.queueBrowseStrategy = queueBrowseStrategy;
        }
    }

    public ActiveMQQueueEndpoint(String uri, JmsComponent component, String destination,
                                 JmsConfiguration configuration, QueueBrowseStrategy queueBrowseStrategy) {
        super(uri, component, destination, false, configuration);
        setDestinationType("queue");
        if (queueBrowseStrategy == null) {
            this.queueBrowseStrategy = createQueueBrowseStrategy();
        } else {
            this.queueBrowseStrategy = queueBrowseStrategy;
        }
    }

    public JmsQueueEndpoint(String uri, JmsComponent component, String destination,
                            JmsConfiguration configuration, QueueBrowseStrategy queueBrowseStrategy) {
        super(uri, component, destination, false, configuration);
        setDestinationType("queue");
        if (queueBrowseStrategy == null) {
            this.queueBrowseStrategy = createQueueBrowseStrategy();
        } else {
            this.queueBrowseStrategy = queueBrowseStrategy;
        }
    }

    public JmsQueueEndpoint(String endpointUri, String destination, QueueBrowseStrategy queueBrowseStrategy) {
        super(endpointUri, destination, false);
        setDestinationType("queue");
        if (queueBrowseStrategy == null) {
            this.queueBrowseStrategy = createQueueBrowseStrategy();
        } else {
            this.queueBrowseStrategy = queueBrowseStrategy;
        }
    }

    public ActiveMQQueueEndpoint(String endpointUri, String destination, QueueBrowseStrategy queueBrowseStrategy) {
        super(endpointUri, destination, false);
        setDestinationType("queue");
        if (queueBrowseStrategy == null) {
            this.queueBrowseStrategy = createQueueBrowseStrategy();
        } else {
            this.queueBrowseStrategy = queueBrowseStrategy;
        }
    }

    public JmsQueueEndpoint(String endpointUri, String destination, QueueBrowseStrategy queueBrowseStrategy) {
        super(endpointUri, destination, false);
        setDestinationType("queue");
        if (queueBrowseStrategy == null) {
            this.queueBrowseStrategy = createQueueBrowseStrategy();
        } else {
            this.queueBrowseStrategy = queueBrowseStrategy;
        }
    }

    public ActiveMQQueueEndpoint(String uri, JmsComponent component, String destination,
                                 JmsConfiguration configuration, QueueBrowseStrategy queueBrowseStrategy) {
        super(uri, component, destination, false, configuration);
        setDestinationType("queue");
        if (queueBrowseStrategy == null) {
            this.queueBrowseStrategy = createQueueBrowseStrategy();
        } else {
            this.queueBrowseStrategy = queueBrowseStrategy;
        }
    }

    public JmsQueueEndpoint(String endpointUri, String destination, QueueBrowseStrategy queueBrowseStrategy) {
        super(endpointUri, destination, false);
        setDestinationType("queue");
        if (queueBrowseStrategy == null) {
            this.queueBrowseStrategy = createQueueBrowseStrategy();
        } else {
            this.queueBrowseStrategy = queueBrowseStrategy;
        }
    }

    public ActiveMQQueueEndpoint(String endpointUri, String destination, QueueBrowseStrategy queueBrowseStrategy) {
        super(endpointUri, destination, false);
        setDestinationType("queue");
        if (queueBrowseStrategy == null) {
            this.queueBrowseStrategy = createQueueBrowseStrategy();
        } else {
            this.queueBrowseStrategy = queueBrowseStrategy;
        }
    }

    public JmsQueueEndpoint(String endpointUri, String destination, QueueBrowseStrategy queueBrowseStrategy) {
        super(endpointUri, destination, false);
        setDestinationType("queue");
        if (queueBrowseStrategy == null) {
            this.queueBrowseStrategy = createQueueBrowseStrategy();
        } else {
            this.queueBrowseStrategy = queueBrowseStrategy;
        }
    }

    public JmsQueueEndpoint(String uri, JmsComponent component, String destination,
                            JmsConfiguration configuration, QueueBrowseStrategy queueBrowseStrategy) {
        super(uri, component, destination, false, configuration);
        setDestinationType("queue");
        if (queueBrowseStrategy == null) {
            this.queueBrowseStrategy = createQueueBrowseStrategy();
        } else {
            this.queueBrowseStrategy = queueBrowseStrategy;
        }
    }

    public ActiveMQQueueEndpoint(String endpointUri, String destination, QueueBrowseStrategy queueBrowseStrategy) {
        super(endpointUri, destination, false);
        setDestinationType("queue");
        if (queueBrowseStrategy == null) {
            this.queueBrowseStrategy = createQueueBrowseStrategy();
        } else {
            this.queueBrowseStrategy = queueBrowseStrategy;
        }
    }

    public ActiveMQQueueEndpoint(String uri, JmsComponent component, String destination,
                                 JmsConfiguration configuration, QueueBrowseStrategy queueBrowseStrategy) {
        super(uri, component, destination, false, configuration);
        setDestinationType("queue");
        if (queueBrowseStrategy == null) {
            this.queueBrowseStrategy = createQueueBrowseStrategy();
        } else {
            this.queueBrowseStrategy = queueBrowseStrategy;
        }
    }

    public ActiveMQQueueEndpoint(String endpointUri, String destination, QueueBrowseStrategy queueBrowseStrategy) {
        super(endpointUri, destination, false);
        setDestinationType("queue");
        if (queueBrowseStrategy == null) {
            this.queueBrowseStrategy = createQueueBrowseStrategy();
        } else {
            this.queueBrowseStrategy = queueBrowseStrategy;
        }
    }

    public ActiveMQQueueEndpoint(String endpointUri, String destination, QueueBrowseStrategy queueBrowseStrategy) {
        super(endpointUri, destination, false);
        setDestinationType("queue");
        if (queueBrowseStrategy == null) {
            this.queueBrowseStrategy = createQueueBrowseStrategy();
        } else {
            this.queueBrowseStrategy = queueBrowseStrategy;
        }
    }

    public ActiveMQQueueEndpoint(String endpointUri, String destination, QueueBrowseStrategy queueBrowseStrategy) {
        super(endpointUri, destination, false);
        setDestinationType("queue");
        if (queueBrowseStrategy == null) {
            this.queueBrowseStrategy = createQueueBrowseStrategy();
        } else {
            this.queueBrowseStrategy = queueBrowseStrategy;
        }
    }

    public JmsQueueEndpoint(String uri, JmsComponent component, String destination,
                            JmsConfiguration configuration, QueueBrowseStrategy queueBrowseStrategy) {
        super(uri, component, destination, false, configuration);
        setDestinationType("queue");
        if (queueBrowseStrategy == null) {
            this.queueBrowseStrategy = createQueueBrowseStrategy();
        } else {
            this.queueBrowseStrategy = queueBrowseStrategy;
        }
    }

    public ActiveMQQueueEndpoint(String uri, JmsComponent component, String destination,
                                 JmsConfiguration configuration, QueueBrowseStrategy queueBrowseStrategy) {
        super(uri, component, destination, false, configuration);
        setDestinationType("queue");
        if (queueBrowseStrategy == null) {
            this.queueBrowseStrategy = createQueueBrowseStrategy();
        } else {
            this.queueBrowseStrategy = queueBrowseStrategy;
        }
    }

    public ActiveMQQueueEndpoint(String endpointUri, String destination, QueueBrowseStrategy queueBrowseStrategy) {
        super(endpointUri, destination, false);
        setDestinationType("queue");
        if (queueBrowseStrategy == null) {
            this.queueBrowseStrategy = createQueueBrowseStrategy();
        } else {
            this.queueBrowseStrategy = queueBrowseStrategy;
        }
    }

    public ActiveMQQueueEndpoint(String uri, JmsComponent component, String destination,
                                 JmsConfiguration configuration, QueueBrowseStrategy queueBrowseStrategy) {
        super(uri, component, destination, false, configuration);
        setDestinationType("queue");
        if (queueBrowseStrategy == null) {
            this.queueBrowseStrategy = createQueueBrowseStrategy();
        } else {
            this.queueBrowseStrategy = queueBrowseStrategy;
        }
    }

    public JmsQueueEndpoint(String uri, JmsComponent component, String destination,
                            JmsConfiguration configuration, QueueBrowseStrategy queueBrowseStrategy) {
        super(uri, component, destination, false, configuration);
        setDestinationType("queue");
        if (queueBrowseStrategy == null) {
            this.queueBrowseStrategy = createQueueBrowseStrategy();
        } else {
            this.queueBrowseStrategy = queueBrowseStrategy;
        }
    }

    public ActiveMQQueueEndpoint(String endpointUri, String destination, QueueBrowseStrategy queueBrowseStrategy) {
        super(endpointUri, destination, false);
        setDestinationType("queue");
        if (queueBrowseStrategy == null) {
            this.queueBrowseStrategy = createQueueBrowseStrategy();
        } else {
            this.queueBrowseStrategy = queueBrowseStrategy;
        }
    }

    public JmsQueueEndpoint(String uri, JmsComponent component, String destination,
                            JmsConfiguration configuration, QueueBrowseStrategy queueBrowseStrategy) {
        super(uri, component, destination, false, configuration);
        setDestinationType("queue");
        if (queueBrowseStrategy == null) {
            this.queueBrowseStrategy = createQueueBrowseStrategy();
        } else {
            this.queueBrowseStrategy = queueBrowseStrategy;
        }
    }

    public List<Exchange> getExchanges(int limit, Predicate filter) {
        if (queueBrowseStrategy == null) {
            return Collections.emptyList();
        }
        String queue = getDestinationName();
        JmsOperations template = getConfiguration().createInOnlyTemplate(this, false, queue);
        List<Exchange> list = queueBrowseStrategy.browse(template, queue, this, limit);
        if (filter != null) {
            list = (List<Exchange>) list.stream().filter(filter).collect(Collectors.toList());
        }
        return list;
    }

    public List<Exchange> getExchanges(int limit, Predicate filter) {
        if (queueBrowseStrategy == null) {
            return Collections.emptyList();
        }
        String queue = getDestinationName();
        JmsOperations template = getConfiguration().createInOnlyTemplate(this, false, queue);
        List<Exchange> list = queueBrowseStrategy.browse(template, queue, this, limit);
        if (filter != null) {
            list = (List<Exchange>) list.stream().filter(filter).collect(Collectors.toList());
        }
        return list;
    }

    public List<Exchange> getExchanges(int limit, Predicate filter) {
        if (queueBrowseStrategy == null) {
            return Collections.emptyList();
        }
        String queue = getDestinationName();
        JmsOperations template = getConfiguration().createInOnlyTemplate(this, false, queue);
        List<Exchange> list = queueBrowseStrategy.browse(template, queue, this, limit);
        if (filter != null) {
            list = (List<Exchange>) list.stream().filter(filter).collect(Collectors.toList());
        }
        return list;
    }

    public List<Exchange> getExchanges(int limit, Predicate filter) {
        if (queueBrowseStrategy == null) {
            return Collections.emptyList();
        }
        String queue = getDestinationName();
        JmsOperations template = getConfiguration().createInOnlyTemplate(this, false, queue);
        List<Exchange> list = queueBrowseStrategy.browse(template, queue, this, limit);
        if (filter != null) {
            list = (List<Exchange>) list.stream().filter(filter).collect(Collectors.toList());
        }
        return list;
    }

    public List<Exchange> getExchanges(int limit, Predicate filter) {
        if (queueBrowseStrategy == null) {
            return Collections.emptyList();
        }
        String queue = getDestinationName();
        JmsOperations template = getConfiguration().createInOnlyTemplate(this, false, queue);
        List<Exchange> list = queueBrowseStrategy.browse(template, queue, this, limit);
        if (filter != null) {
            list = (List<Exchange>) list.stream().filter(filter).collect(Collectors.toList());
        }
        return list;
    }

    public List<Exchange> getExchanges(int limit, Predicate filter) {
        if (queueBrowseStrategy == null) {
            return Collections.emptyList();
        }
        String queue = getDestinationName();
        JmsOperations template = getConfiguration().createInOnlyTemplate(this, false, queue);
        List<Exchange> list = queueBrowseStrategy.browse(template, queue, this, limit);
        if (filter != null) {
            list = (List<Exchange>) list.stream().filter(filter).collect(Collectors.toList());
        }
        return list;
    }

    public Processor toProcessor(final MessageListener listener) {
        return new Processor() {
            public void process(Exchange exchange) throws Exception {
                Message message = toMessage(exchange);
                listener.onMessage(message);
            }

            @Override
            public String toString() {
                return "Processor of MessageListener: " + listener;
            }
        };
    }

    public Processor toProcessor(final MessageListener listener) {
        return new Processor() {
            public void process(Exchange exchange) throws Exception {
                Message message = toMessage(exchange);
                listener.onMessage(message);
            }

            @Override
            public String toString() {
                return "Processor of MessageListener: " + listener;
            }
        };
    }

    private static ActiveMQMessage createActiveMQMessage(Exchange exchange) throws JMSException {
        Object body = exchange.getIn().getBody();
        if (body instanceof String) {
            ActiveMQTextMessage answer = new ActiveMQTextMessage();
            answer.setText((String) body);
            return answer;
        } else if (body instanceof Serializable) {
            ActiveMQObjectMessage answer = new ActiveMQObjectMessage();
            answer.setObject((Serializable) body);
            return answer;
        } else {
            return new ActiveMQMessage();
        }

    }

    private static ActiveMQMessage createActiveMQMessage(Exchange exchange) throws JMSException {
        Object body = exchange.getIn().getBody();
        if (body instanceof String) {
            ActiveMQTextMessage answer = new ActiveMQTextMessage();
            answer.setText((String) body);
            return answer;
        } else if (body instanceof Serializable) {
            ActiveMQObjectMessage answer = new ActiveMQObjectMessage();
            answer.setObject((Serializable) body);
            return answer;
        } else {
            return new ActiveMQMessage();
        }

    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, org.apache.activemq.command.ActiveMQMessage.class, org.apache.camel.Exchange.class, false,
            (type, exchange, value) -> {
                Object answer = getActiveMQMessageConverter().toMessage((org.apache.camel.Exchange) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.camel.Processor.class, jakarta.jms.MessageListener.class, false,
            (type, exchange, value) -> {
                Object answer = getActiveMQMessageConverter().toProcessor((jakarta.jms.MessageListener) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, org.apache.activemq.command.ActiveMQMessage.class, org.apache.camel.Exchange.class, false,
            (type, exchange, value) -> {
                Object answer = getActiveMQMessageConverter().toMessage((org.apache.camel.Exchange) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.camel.Processor.class, jakarta.jms.MessageListener.class, false,
            (type, exchange, value) -> {
                Object answer = getActiveMQMessageConverter().toProcessor((jakarta.jms.MessageListener) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, org.apache.activemq.command.ActiveMQMessage.class, org.apache.camel.Exchange.class, false,
            (type, exchange, value) -> {
                Object answer = getActiveMQMessageConverter().toMessage((org.apache.camel.Exchange) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.camel.Processor.class, jakarta.jms.MessageListener.class, false,
            (type, exchange, value) -> {
                Object answer = getActiveMQMessageConverter().toProcessor((jakarta.jms.MessageListener) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, java.util.List.class, org.dizitart.no2.Cursor.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.nitrite.NitriteTypeConverters.fromCursorToList((org.dizitart.no2.Cursor) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.dizitart.no2.Document.class, java.util.Map.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.nitrite.NitriteTypeConverters.fromMapToDocument((java.util.Map) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, org.apache.activemq.command.ActiveMQMessage.class, org.apache.camel.Exchange.class, false,
            (type, exchange, value) -> {
                Object answer = getActiveMQMessageConverter().toMessage((org.apache.camel.Exchange) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.camel.Processor.class, jakarta.jms.MessageListener.class, false,
            (type, exchange, value) -> {
                Object answer = getActiveMQMessageConverter().toProcessor((jakarta.jms.MessageListener) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, org.eclipse.tahu.message.model.SparkplugBPayload.class, org.apache.camel.Exchange.class, false,
            (type, exchange, value) -> {
                Object answer = getTahuEdgePayloadConverter().exchangeToSparkplugBPayload((org.apache.camel.Exchange) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.eclipse.tahu.message.model.SparkplugBPayload.class, org.apache.camel.Message.class, false,
            (type, exchange, value) -> {
                Object answer = getTahuEdgePayloadConverter().messageToSparkplugBPayload((org.apache.camel.Message) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, org.apache.activemq.command.ActiveMQMessage.class, org.apache.camel.Exchange.class, false,
            (type, exchange, value) -> {
                Object answer = getActiveMQMessageConverter().toMessage((org.apache.camel.Exchange) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.camel.Processor.class, jakarta.jms.MessageListener.class, false,
            (type, exchange, value) -> {
                Object answer = getActiveMQMessageConverter().toProcessor((jakarta.jms.MessageListener) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, com.twilio.type.Endpoint.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.twilio.TwilioConverter.toPhoneNumber((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, com.twilio.type.Sip.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.twilio.TwilioConverter.toSip((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, org.apache.activemq.command.ActiveMQMessage.class, org.apache.camel.Exchange.class, false,
            (type, exchange, value) -> {
                Object answer = getActiveMQMessageConverter().toMessage((org.apache.camel.Exchange) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.camel.Processor.class, jakarta.jms.MessageListener.class, false,
            (type, exchange, value) -> {
                Object answer = getActiveMQMessageConverter().toProcessor((jakarta.jms.MessageListener) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, java.lang.String.class, org.apache.camel.component.syslog.SyslogMessage.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.syslog.SyslogConverter.toString((org.apache.camel.component.syslog.SyslogMessage) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.camel.component.syslog.SyslogMessage.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.syslog.SyslogConverter.toSyslogMessage((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, org.apache.activemq.command.ActiveMQMessage.class, org.apache.camel.Exchange.class, false,
            (type, exchange, value) -> {
                Object answer = getActiveMQMessageConverter().toMessage((org.apache.camel.Exchange) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.camel.Processor.class, jakarta.jms.MessageListener.class, false,
            (type, exchange, value) -> {
                Object answer = getActiveMQMessageConverter().toProcessor((jakarta.jms.MessageListener) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, java.lang.String.class, org.snmp4j.PDU.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.snmp.SnmpConverters.toString((org.snmp4j.PDU) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.camel.component.snmp.OIDList.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.snmp.SnmpConverters.toOIDList((java.lang.String) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, org.apache.activemq.command.ActiveMQMessage.class, org.apache.camel.Exchange.class, false,
            (type, exchange, value) -> {
                Object answer = getActiveMQMessageConverter().toMessage((org.apache.camel.Exchange) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.camel.Processor.class, jakarta.jms.MessageListener.class, false,
            (type, exchange, value) -> {
                Object answer = getActiveMQMessageConverter().toProcessor((jakarta.jms.MessageListener) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, com.rometools.rome.feed.synd.SyndFeed.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.dataformat.rss.RssConverter.xmlToFeed((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, java.lang.String.class, com.rometools.rome.feed.synd.SyndFeed.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.dataformat.rss.RssConverter.feedToXml((com.rometools.rome.feed.synd.SyndFeed) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, org.apache.activemq.command.ActiveMQMessage.class, org.apache.camel.Exchange.class, false,
            (type, exchange, value) -> {
                Object answer = getActiveMQMessageConverter().toMessage((org.apache.camel.Exchange) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.camel.Processor.class, jakarta.jms.MessageListener.class, false,
            (type, exchange, value) -> {
                Object answer = getActiveMQMessageConverter().toProcessor((jakarta.jms.MessageListener) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, com.mongodb.ReadPreference.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.mongodb.gridfs.GridFsConverter.toReadPreference((java.lang.String) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, com.mongodb.WriteConcern.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.mongodb.gridfs.GridFsConverter.toWriteConcern((java.lang.String) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, org.apache.activemq.command.ActiveMQMessage.class, org.apache.camel.Exchange.class, false,
            (type, exchange, value) -> {
                Object answer = getActiveMQMessageConverter().toMessage((org.apache.camel.Exchange) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.camel.Processor.class, jakarta.jms.MessageListener.class, false,
            (type, exchange, value) -> {
                Object answer = getActiveMQMessageConverter().toProcessor((jakarta.jms.MessageListener) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, java.util.List.class, org.dizitart.no2.Cursor.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.nitrite.NitriteTypeConverters.fromCursorToList((org.dizitart.no2.Cursor) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.dizitart.no2.Document.class, java.util.Map.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.nitrite.NitriteTypeConverters.fromMapToDocument((java.util.Map) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, org.apache.activemq.command.ActiveMQMessage.class, org.apache.camel.Exchange.class, false,
            (type, exchange, value) -> {
                Object answer = getActiveMQMessageConverter().toMessage((org.apache.camel.Exchange) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.camel.Processor.class, jakarta.jms.MessageListener.class, false,
            (type, exchange, value) -> {
                Object answer = getActiveMQMessageConverter().toProcessor((jakarta.jms.MessageListener) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, org.eclipse.tahu.message.model.SparkplugBPayload.class, org.apache.camel.Exchange.class, false,
            (type, exchange, value) -> {
                Object answer = getTahuEdgePayloadConverter().exchangeToSparkplugBPayload((org.apache.camel.Exchange) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.eclipse.tahu.message.model.SparkplugBPayload.class, org.apache.camel.Message.class, false,
            (type, exchange, value) -> {
                Object answer = getTahuEdgePayloadConverter().messageToSparkplugBPayload((org.apache.camel.Message) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, org.apache.activemq.command.ActiveMQMessage.class, org.apache.camel.Exchange.class, false,
            (type, exchange, value) -> {
                Object answer = getActiveMQMessageConverter().toMessage((org.apache.camel.Exchange) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.camel.Processor.class, jakarta.jms.MessageListener.class, false,
            (type, exchange, value) -> {
                Object answer = getActiveMQMessageConverter().toProcessor((jakarta.jms.MessageListener) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, com.twilio.type.Endpoint.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.twilio.TwilioConverter.toPhoneNumber((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, com.twilio.type.Sip.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.twilio.TwilioConverter.toSip((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, org.apache.activemq.command.ActiveMQMessage.class, org.apache.camel.Exchange.class, false,
            (type, exchange, value) -> {
                Object answer = getActiveMQMessageConverter().toMessage((org.apache.camel.Exchange) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.camel.Processor.class, jakarta.jms.MessageListener.class, false,
            (type, exchange, value) -> {
                Object answer = getActiveMQMessageConverter().toProcessor((jakarta.jms.MessageListener) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, java.lang.String.class, org.apache.camel.component.syslog.SyslogMessage.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.syslog.SyslogConverter.toString((org.apache.camel.component.syslog.SyslogMessage) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.camel.component.syslog.SyslogMessage.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.syslog.SyslogConverter.toSyslogMessage((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, org.apache.activemq.command.ActiveMQMessage.class, org.apache.camel.Exchange.class, false,
            (type, exchange, value) -> {
                Object answer = getActiveMQMessageConverter().toMessage((org.apache.camel.Exchange) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.camel.Processor.class, jakarta.jms.MessageListener.class, false,
            (type, exchange, value) -> {
                Object answer = getActiveMQMessageConverter().toProcessor((jakarta.jms.MessageListener) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, java.lang.String.class, org.snmp4j.PDU.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.snmp.SnmpConverters.toString((org.snmp4j.PDU) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.camel.component.snmp.OIDList.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.snmp.SnmpConverters.toOIDList((java.lang.String) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, org.apache.activemq.command.ActiveMQMessage.class, org.apache.camel.Exchange.class, false,
            (type, exchange, value) -> {
                Object answer = getActiveMQMessageConverter().toMessage((org.apache.camel.Exchange) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.camel.Processor.class, jakarta.jms.MessageListener.class, false,
            (type, exchange, value) -> {
                Object answer = getActiveMQMessageConverter().toProcessor((jakarta.jms.MessageListener) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, com.rometools.rome.feed.synd.SyndFeed.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.dataformat.rss.RssConverter.xmlToFeed((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, java.lang.String.class, com.rometools.rome.feed.synd.SyndFeed.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.dataformat.rss.RssConverter.feedToXml((com.rometools.rome.feed.synd.SyndFeed) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, org.apache.activemq.command.ActiveMQMessage.class, org.apache.camel.Exchange.class, false,
            (type, exchange, value) -> {
                Object answer = getActiveMQMessageConverter().toMessage((org.apache.camel.Exchange) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.camel.Processor.class, jakarta.jms.MessageListener.class, false,
            (type, exchange, value) -> {
                Object answer = getActiveMQMessageConverter().toProcessor((jakarta.jms.MessageListener) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, com.mongodb.ReadPreference.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.mongodb.gridfs.GridFsConverter.toReadPreference((java.lang.String) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, com.mongodb.WriteConcern.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.mongodb.gridfs.GridFsConverter.toWriteConcern((java.lang.String) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, java.util.List.class, org.dizitart.no2.Cursor.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.nitrite.NitriteTypeConverters.fromCursorToList((org.dizitart.no2.Cursor) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.dizitart.no2.Document.class, java.util.Map.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.nitrite.NitriteTypeConverters.fromMapToDocument((java.util.Map) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, org.eclipse.tahu.message.model.SparkplugBPayload.class, org.apache.camel.Exchange.class, false,
            (type, exchange, value) -> {
                Object answer = getTahuEdgePayloadConverter().exchangeToSparkplugBPayload((org.apache.camel.Exchange) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.eclipse.tahu.message.model.SparkplugBPayload.class, org.apache.camel.Message.class, false,
            (type, exchange, value) -> {
                Object answer = getTahuEdgePayloadConverter().messageToSparkplugBPayload((org.apache.camel.Message) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, java.util.List.class, org.dizitart.no2.Cursor.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.nitrite.NitriteTypeConverters.fromCursorToList((org.dizitart.no2.Cursor) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.dizitart.no2.Document.class, java.util.Map.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.nitrite.NitriteTypeConverters.fromMapToDocument((java.util.Map) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, com.twilio.type.Endpoint.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.twilio.TwilioConverter.toPhoneNumber((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, com.twilio.type.Sip.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.twilio.TwilioConverter.toSip((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, java.util.List.class, org.dizitart.no2.Cursor.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.nitrite.NitriteTypeConverters.fromCursorToList((org.dizitart.no2.Cursor) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.dizitart.no2.Document.class, java.util.Map.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.nitrite.NitriteTypeConverters.fromMapToDocument((java.util.Map) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, java.lang.String.class, org.apache.camel.component.syslog.SyslogMessage.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.syslog.SyslogConverter.toString((org.apache.camel.component.syslog.SyslogMessage) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.camel.component.syslog.SyslogMessage.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.syslog.SyslogConverter.toSyslogMessage((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, java.util.List.class, org.dizitart.no2.Cursor.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.nitrite.NitriteTypeConverters.fromCursorToList((org.dizitart.no2.Cursor) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.dizitart.no2.Document.class, java.util.Map.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.nitrite.NitriteTypeConverters.fromMapToDocument((java.util.Map) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, java.lang.String.class, org.snmp4j.PDU.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.snmp.SnmpConverters.toString((org.snmp4j.PDU) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.camel.component.snmp.OIDList.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.snmp.SnmpConverters.toOIDList((java.lang.String) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, java.util.List.class, org.dizitart.no2.Cursor.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.nitrite.NitriteTypeConverters.fromCursorToList((org.dizitart.no2.Cursor) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.dizitart.no2.Document.class, java.util.Map.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.nitrite.NitriteTypeConverters.fromMapToDocument((java.util.Map) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, com.rometools.rome.feed.synd.SyndFeed.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.dataformat.rss.RssConverter.xmlToFeed((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, java.lang.String.class, com.rometools.rome.feed.synd.SyndFeed.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.dataformat.rss.RssConverter.feedToXml((com.rometools.rome.feed.synd.SyndFeed) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, java.util.List.class, org.dizitart.no2.Cursor.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.nitrite.NitriteTypeConverters.fromCursorToList((org.dizitart.no2.Cursor) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.dizitart.no2.Document.class, java.util.Map.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.nitrite.NitriteTypeConverters.fromMapToDocument((java.util.Map) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, com.mongodb.ReadPreference.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.mongodb.gridfs.GridFsConverter.toReadPreference((java.lang.String) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, com.mongodb.WriteConcern.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.mongodb.gridfs.GridFsConverter.toWriteConcern((java.lang.String) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, org.eclipse.tahu.message.model.SparkplugBPayload.class, org.apache.camel.Exchange.class, false,
            (type, exchange, value) -> {
                Object answer = getTahuEdgePayloadConverter().exchangeToSparkplugBPayload((org.apache.camel.Exchange) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.eclipse.tahu.message.model.SparkplugBPayload.class, org.apache.camel.Message.class, false,
            (type, exchange, value) -> {
                Object answer = getTahuEdgePayloadConverter().messageToSparkplugBPayload((org.apache.camel.Message) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, com.twilio.type.Endpoint.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.twilio.TwilioConverter.toPhoneNumber((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, com.twilio.type.Sip.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.twilio.TwilioConverter.toSip((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, org.eclipse.tahu.message.model.SparkplugBPayload.class, org.apache.camel.Exchange.class, false,
            (type, exchange, value) -> {
                Object answer = getTahuEdgePayloadConverter().exchangeToSparkplugBPayload((org.apache.camel.Exchange) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.eclipse.tahu.message.model.SparkplugBPayload.class, org.apache.camel.Message.class, false,
            (type, exchange, value) -> {
                Object answer = getTahuEdgePayloadConverter().messageToSparkplugBPayload((org.apache.camel.Message) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, java.lang.String.class, org.apache.camel.component.syslog.SyslogMessage.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.syslog.SyslogConverter.toString((org.apache.camel.component.syslog.SyslogMessage) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.camel.component.syslog.SyslogMessage.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.syslog.SyslogConverter.toSyslogMessage((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, org.eclipse.tahu.message.model.SparkplugBPayload.class, org.apache.camel.Exchange.class, false,
            (type, exchange, value) -> {
                Object answer = getTahuEdgePayloadConverter().exchangeToSparkplugBPayload((org.apache.camel.Exchange) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.eclipse.tahu.message.model.SparkplugBPayload.class, org.apache.camel.Message.class, false,
            (type, exchange, value) -> {
                Object answer = getTahuEdgePayloadConverter().messageToSparkplugBPayload((org.apache.camel.Message) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, java.lang.String.class, org.snmp4j.PDU.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.snmp.SnmpConverters.toString((org.snmp4j.PDU) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.camel.component.snmp.OIDList.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.snmp.SnmpConverters.toOIDList((java.lang.String) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, org.eclipse.tahu.message.model.SparkplugBPayload.class, org.apache.camel.Exchange.class, false,
            (type, exchange, value) -> {
                Object answer = getTahuEdgePayloadConverter().exchangeToSparkplugBPayload((org.apache.camel.Exchange) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.eclipse.tahu.message.model.SparkplugBPayload.class, org.apache.camel.Message.class, false,
            (type, exchange, value) -> {
                Object answer = getTahuEdgePayloadConverter().messageToSparkplugBPayload((org.apache.camel.Message) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, com.rometools.rome.feed.synd.SyndFeed.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.dataformat.rss.RssConverter.xmlToFeed((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, java.lang.String.class, com.rometools.rome.feed.synd.SyndFeed.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.dataformat.rss.RssConverter.feedToXml((com.rometools.rome.feed.synd.SyndFeed) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, org.eclipse.tahu.message.model.SparkplugBPayload.class, org.apache.camel.Exchange.class, false,
            (type, exchange, value) -> {
                Object answer = getTahuEdgePayloadConverter().exchangeToSparkplugBPayload((org.apache.camel.Exchange) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.eclipse.tahu.message.model.SparkplugBPayload.class, org.apache.camel.Message.class, false,
            (type, exchange, value) -> {
                Object answer = getTahuEdgePayloadConverter().messageToSparkplugBPayload((org.apache.camel.Message) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, com.mongodb.ReadPreference.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.mongodb.gridfs.GridFsConverter.toReadPreference((java.lang.String) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, com.mongodb.WriteConcern.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.mongodb.gridfs.GridFsConverter.toWriteConcern((java.lang.String) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, com.twilio.type.Endpoint.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.twilio.TwilioConverter.toPhoneNumber((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, com.twilio.type.Sip.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.twilio.TwilioConverter.toSip((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, java.lang.String.class, org.apache.camel.component.syslog.SyslogMessage.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.syslog.SyslogConverter.toString((org.apache.camel.component.syslog.SyslogMessage) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.camel.component.syslog.SyslogMessage.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.syslog.SyslogConverter.toSyslogMessage((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, com.twilio.type.Endpoint.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.twilio.TwilioConverter.toPhoneNumber((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, com.twilio.type.Sip.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.twilio.TwilioConverter.toSip((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, java.lang.String.class, org.snmp4j.PDU.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.snmp.SnmpConverters.toString((org.snmp4j.PDU) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.camel.component.snmp.OIDList.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.snmp.SnmpConverters.toOIDList((java.lang.String) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, com.twilio.type.Endpoint.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.twilio.TwilioConverter.toPhoneNumber((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, com.twilio.type.Sip.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.twilio.TwilioConverter.toSip((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, com.rometools.rome.feed.synd.SyndFeed.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.dataformat.rss.RssConverter.xmlToFeed((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, java.lang.String.class, com.rometools.rome.feed.synd.SyndFeed.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.dataformat.rss.RssConverter.feedToXml((com.rometools.rome.feed.synd.SyndFeed) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, com.twilio.type.Endpoint.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.twilio.TwilioConverter.toPhoneNumber((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, com.twilio.type.Sip.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.twilio.TwilioConverter.toSip((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, com.mongodb.ReadPreference.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.mongodb.gridfs.GridFsConverter.toReadPreference((java.lang.String) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, com.mongodb.WriteConcern.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.mongodb.gridfs.GridFsConverter.toWriteConcern((java.lang.String) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, java.lang.String.class, org.apache.camel.component.syslog.SyslogMessage.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.syslog.SyslogConverter.toString((org.apache.camel.component.syslog.SyslogMessage) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.camel.component.syslog.SyslogMessage.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.syslog.SyslogConverter.toSyslogMessage((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, java.lang.String.class, org.snmp4j.PDU.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.snmp.SnmpConverters.toString((org.snmp4j.PDU) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.camel.component.snmp.OIDList.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.snmp.SnmpConverters.toOIDList((java.lang.String) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, java.lang.String.class, org.apache.camel.component.syslog.SyslogMessage.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.syslog.SyslogConverter.toString((org.apache.camel.component.syslog.SyslogMessage) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.camel.component.syslog.SyslogMessage.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.syslog.SyslogConverter.toSyslogMessage((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, com.rometools.rome.feed.synd.SyndFeed.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.dataformat.rss.RssConverter.xmlToFeed((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, java.lang.String.class, com.rometools.rome.feed.synd.SyndFeed.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.dataformat.rss.RssConverter.feedToXml((com.rometools.rome.feed.synd.SyndFeed) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, java.lang.String.class, org.apache.camel.component.syslog.SyslogMessage.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.syslog.SyslogConverter.toString((org.apache.camel.component.syslog.SyslogMessage) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.camel.component.syslog.SyslogMessage.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.syslog.SyslogConverter.toSyslogMessage((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, com.mongodb.ReadPreference.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.mongodb.gridfs.GridFsConverter.toReadPreference((java.lang.String) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, com.mongodb.WriteConcern.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.mongodb.gridfs.GridFsConverter.toWriteConcern((java.lang.String) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, java.lang.String.class, org.snmp4j.PDU.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.snmp.SnmpConverters.toString((org.snmp4j.PDU) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.camel.component.snmp.OIDList.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.snmp.SnmpConverters.toOIDList((java.lang.String) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, com.rometools.rome.feed.synd.SyndFeed.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.dataformat.rss.RssConverter.xmlToFeed((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, java.lang.String.class, com.rometools.rome.feed.synd.SyndFeed.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.dataformat.rss.RssConverter.feedToXml((com.rometools.rome.feed.synd.SyndFeed) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, java.lang.String.class, org.snmp4j.PDU.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.snmp.SnmpConverters.toString((org.snmp4j.PDU) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.camel.component.snmp.OIDList.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.snmp.SnmpConverters.toOIDList((java.lang.String) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, com.mongodb.ReadPreference.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.mongodb.gridfs.GridFsConverter.toReadPreference((java.lang.String) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, com.mongodb.WriteConcern.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.mongodb.gridfs.GridFsConverter.toWriteConcern((java.lang.String) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, com.rometools.rome.feed.synd.SyndFeed.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.dataformat.rss.RssConverter.xmlToFeed((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, java.lang.String.class, com.rometools.rome.feed.synd.SyndFeed.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.dataformat.rss.RssConverter.feedToXml((com.rometools.rome.feed.synd.SyndFeed) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, com.mongodb.ReadPreference.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.mongodb.gridfs.GridFsConverter.toReadPreference((java.lang.String) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, com.mongodb.WriteConcern.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.mongodb.gridfs.GridFsConverter.toWriteConcern((java.lang.String) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    static long write(FileChannel fileChannel, ByteBuffer byteBuffer, long position) throws IOException {
        long bytesWritten = 0;
        byteBuffer.flip();

        while (byteBuffer.hasRemaining()) {
            bytesWritten += fileChannel.write(byteBuffer, position + bytesWritten);
        }

        byteBuffer.flip();
        byteBuffer.clear();

        return bytesWritten;
    }

    static long write(FileChannel fileChannel, ByteBuffer byteBuffer) throws IOException {
        long bytesWritten = 0;
        byteBuffer.flip();

        while (byteBuffer.hasRemaining()) {
            bytesWritten += fileChannel.write(byteBuffer);
        }

        byteBuffer.flip();
        byteBuffer.clear();

        return bytesWritten;
    }

    private void handleResult(EntryInfo.CachedEntryInfo entryInfo, Throwable t) {
        try {
            if (t == null) {
                logWriter.updateState(entryInfo, LogEntry.EntryState.PROCESSED);
            } else {
                logWriter.updateState(entryInfo, LogEntry.EntryState.FAILED);
            }
        } catch (IOException e) {
            if (t == null) {
                LOG.error("Unable to update state: {}", e.getMessage(), e);
            } else {
                LOG.error("Unable to mark the record as failed: {}", e.getMessage(), e);
            }
        }
    }

    private void handleResult(PersistedLogEntry entry, Throwable t) {
        try {
            if (t == null) {
                logWriter.updateState(entry, LogEntry.EntryState.PROCESSED);
            } else {
                logWriter.updateState(entry, LogEntry.EntryState.FAILED);
            }
        } catch (IOException e) {
            if (t == null) {
                LOG.error("Unable to update state: {}", e.getMessage(), e);
            } else {
                LOG.error("Unable to mark the record as failed: {}", e.getMessage(), e);
            }
        }
    }

    private void tryFlush() {
        lock.lock();
        try {
            flush();
        } catch (IOException e) {
            LOG.error("Unable to save record: {}", e.getMessage(), e);
            throw new RuntimeException(e);
        } finally {
            lock.unlock();
        }
    }

    private void retainClusterView() {
        lock.lock();
        try {
            clusterView = clusterService.getView(namespace);
            clusterView.addEventListener(leadershipEventListener);
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            lock.unlock();
        }
    }

    public static String parseVariables(String url, Server server) {
        Pattern p = Pattern.compile("\\{(.*?)}");
        Matcher m = p.matcher(url);
        while (m.find()) {
            String variable = m.group(1);
            if (server != null && server.getVariables() != null && server.getVariables().get(variable) != null) {
                String varValue = server.getVariables().get(variable).getDefault();
                url = url.replace("{" + variable + "}", varValue);
            }
        }
        return url;
    }

    public static String parseVariables(String url, Server server) {
        Pattern p = Pattern.compile("\\{(.*?)\\}");
        Matcher m = p.matcher(url);
        while (m.find()) {

            String variable = m.group(1);
            if (server != null && server.getVariables() != null && server.getVariables().get(variable) != null) {
                String varValue = server.getVariables().get(variable).getDefault();
                url = url.replace("{" + variable + "}", varValue);
            }
        }
        return url;
    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
        JCacheConfiguration configuration = new JCacheConfiguration(getCamelContext(), remaining);

        configuration.setCachingProvider(cachingProvider);
        configuration.setCacheConfiguration(cacheConfiguration);
        configuration.setCacheConfigurationProperties(loadProperties());
        configuration.setConfigurationUri(configurationUri);

        JCacheEndpoint endpoint = new JCacheEndpoint(uri, this, configuration);
        setProperties(endpoint, parameters);
        return endpoint;
    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
        StripeConfiguration configuration = new StripeConfiguration();
        configuration.setOperation(remaining);

        if (apiKey != null) {
            configuration.setApiKey(apiKey);
        }
        if (apiBase != null) {
            configuration.setApiBase(apiBase);
        }

        StripeEndpoint endpoint = new StripeEndpoint(uri, this, configuration);
        setProperties(endpoint, parameters);

        return endpoint;
    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
        JCacheConfiguration configuration = new JCacheConfiguration(getCamelContext(), remaining);

        configuration.setCachingProvider(cachingProvider);
        configuration.setCacheConfiguration(cacheConfiguration);
        configuration.setCacheConfigurationProperties(loadProperties());
        configuration.setConfigurationUri(configurationUri);

        JCacheEndpoint endpoint = new JCacheEndpoint(uri, this, configuration);
        setProperties(endpoint, parameters);
        return endpoint;
    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
        OpenAIConfiguration configuration = new OpenAIConfiguration();

        if (apiKey != null) {
            configuration.setApiKey(apiKey);
        }
        if (baseUrl != null) {
            configuration.setBaseUrl(baseUrl);
        }
        if (model != null) {
            configuration.setModel(model);
        }

        OpenAIEndpoint endpoint = new OpenAIEndpoint(uri, this, configuration);
         
        endpoint.setOperation(remaining);
        setProperties(endpoint, parameters);

        return endpoint;
    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
        StripeConfiguration configuration = new StripeConfiguration();
        configuration.setOperation(remaining);

        if (apiKey != null) {
            configuration.setApiKey(apiKey);
        }
        if (apiBase != null) {
            configuration.setApiBase(apiBase);
        }

        StripeEndpoint endpoint = new StripeEndpoint(uri, this, configuration);
        setProperties(endpoint, parameters);

        return endpoint;
    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
        OpenAIConfiguration configuration = new OpenAIConfiguration();

        if (apiKey != null) {
            configuration.setApiKey(apiKey);
        }
        if (baseUrl != null) {
            configuration.setBaseUrl(baseUrl);
        }
        if (model != null) {
            configuration.setModel(model);
        }

        OpenAIEndpoint endpoint = new OpenAIEndpoint(uri, this, configuration);
         
        endpoint.setOperation(remaining);
        setProperties(endpoint, parameters);

        return endpoint;
    }

    public void close() throws IOException {
        lock.lock();
        try {
            if (configuration != null) {
                if (cache != null) {
                    cache.close();
                }

                if (manager != null) {
                    manager.close();
                }

                if (provider != null) {
                    provider.close();
                }
            }
        } finally {
            lock.unlock();
        }
    }

    public void forceDisconnect() throws GenericFileOperationFailedException {
        lock.lock();
        try {
            if (session != null) {
                session.disconnect();
            }
            if (channel != null) {
                channel.disconnect();
            }
        } finally {
             
            session = null;
            channel = null;
            lock.unlock();
        }
    }

    protected void doStart() throws Exception {
        ObjectHelper.notNull(camelContext, "camelContext");
        ObjectHelper.notNull(configuration, "configuration");

        if (cache != null) {
            cacheManager = new JCacheManager<>(cache);
        } else {
            cacheManager = JCacheHelper.createManager(getCamelContext(), configuration);
            cache = cacheManager.getCache();
        }
    }

    protected void doStart() throws Exception {
        ObjectHelper.notNull(camelContext, "camelContext");
        ObjectHelper.notNull(configuration, "configuration");

        if (cache != null) {
            cacheManager = new JCacheManager<>(cache);
        } else {
            cacheManager = JCacheHelper.createManager(getCamelContext(), configuration);
            cache = cacheManager.getCache();
        }
    }

    public Exchange add(CamelContext camelContext, String key, Exchange oldExchange, Exchange newExchange)
            throws OptimisticLockingException {
        if (!optimistic) {
            throw new UnsupportedOperationException();
        }

        LOG.trace("Adding an Exchange with ID {} for key {} in an optimistic manner.", newExchange.getExchangeId(), key);
        if (oldExchange == null) {
            DefaultExchangeHolder newHolder = DefaultExchangeHolder.marshal(newExchange, true, allowSerializedHeaders);
            DefaultExchangeHolder oldHolder = cache.getAndPut(key, newHolder);
            if (oldHolder != null) {
                Exchange exchange = unmarshallExchange(camelContext, oldHolder);
                LOG.error(
                        "Optimistic locking failed for exchange with key {}: IMap#putIfAbsend returned Exchange with ID {}, while it's expected no exchanges to be returned",
                        key,
                        exchange != null ? exchange.getExchangeId() : "<null>");

                throw new OptimisticLockingException();
            }
        } else {
            DefaultExchangeHolder oldHolder = DefaultExchangeHolder.marshal(oldExchange, true, allowSerializedHeaders);
            DefaultExchangeHolder newHolder = DefaultExchangeHolder.marshal(newExchange, true, allowSerializedHeaders);
            if (!cache.replace(key, oldHolder, newHolder)) {
                LOG.error(
                        "Optimistic locking failed for exchange with key {}: IMap#replace returned no Exchanges, while it's expected to replace one",
                        key);
                throw new OptimisticLockingException();
            }
        }
        LOG.trace("Added an Exchange with ID {} for key {} in optimistic manner.", newExchange.getExchangeId(), key);
        return oldExchange;
    }

    public Exchange add(CamelContext camelContext, String key, Exchange oldExchange, Exchange newExchange)
            throws OptimisticLockingException {
        if (!optimistic) {
            throw new UnsupportedOperationException();
        }
        LOG.trace("Adding an Exchange with ID {} for key {} in an optimistic manner.", newExchange.getExchangeId(), key);
        if (oldExchange == null) {
            DefaultExchangeHolder holder = DefaultExchangeHolder.marshal(newExchange, true, allowSerializedHeaders);
            final DefaultExchangeHolder misbehaviorHolder = replicatedCache.putIfAbsent(key, holder);
            if (misbehaviorHolder != null) {
                Exchange misbehaviorEx = unmarshallExchange(camelContext, misbehaviorHolder);
                LOG.error(
                        "Optimistic locking failed for exchange with key {}: IMap#putIfAbsend returned Exchange with ID {}, while it's expected no exchanges to be returned",
                        key, misbehaviorEx != null ? misbehaviorEx.getExchangeId() : "<null>");
                throw new OptimisticLockingException();
            }
        } else {
            DefaultExchangeHolder oldHolder = DefaultExchangeHolder.marshal(oldExchange, true, allowSerializedHeaders);
            DefaultExchangeHolder newHolder = DefaultExchangeHolder.marshal(newExchange, true, allowSerializedHeaders);
            if (!replicatedCache.replace(key, oldHolder, newHolder)) {
                LOG.error(
                        "Optimistic locking failed for exchange with key {}: IMap#replace returned no Exchanges, while it's expected to replace one",
                        key);
                throw new OptimisticLockingException();
            }
        }
        LOG.trace("Added an Exchange with ID {} for key {} in optimistic manner.", newExchange.getExchangeId(), key);
        return oldExchange;
    }

    public Exchange add(CamelContext camelContext, String key, Exchange oldExchange, Exchange newExchange)
            throws OptimisticLockingException {
        if (!optimistic) {
            throw new UnsupportedOperationException();
        }

        LOG.trace("Adding an Exchange with ID {} for key {} in an optimistic manner.", newExchange.getExchangeId(), key);
        if (oldExchange == null) {
            DefaultExchangeHolder newHolder = DefaultExchangeHolder.marshal(newExchange, true, allowSerializedHeaders);
            DefaultExchangeHolder oldHolder = cache.getAndPut(key, newHolder);
            if (oldHolder != null) {
                Exchange exchange = unmarshallExchange(camelContext, oldHolder);
                LOG.error(
                        "Optimistic locking failed for exchange with key {}: IMap#putIfAbsend returned Exchange with ID {}, while it's expected no exchanges to be returned",
                        key,
                        exchange != null ? exchange.getExchangeId() : "<null>");

                throw new OptimisticLockingException();
            }
        } else {
            DefaultExchangeHolder oldHolder = DefaultExchangeHolder.marshal(oldExchange, true, allowSerializedHeaders);
            DefaultExchangeHolder newHolder = DefaultExchangeHolder.marshal(newExchange, true, allowSerializedHeaders);
            if (!cache.replace(key, oldHolder, newHolder)) {
                LOG.error(
                        "Optimistic locking failed for exchange with key {}: IMap#replace returned no Exchanges, while it's expected to replace one",
                        key);
                throw new OptimisticLockingException();
            }
        }
        LOG.trace("Added an Exchange with ID {} for key {} in optimistic manner.", newExchange.getExchangeId(), key);
        return oldExchange;
    }

    public Exchange add(CamelContext camelContext, String key, Exchange oldExchange, Exchange newExchange)
            throws OptimisticLockingException {
        if (!optimistic) {
            throw new UnsupportedOperationException();
        }
        LOG.trace("Adding an Exchange with ID {} for key {} in an optimistic manner.", newExchange.getExchangeId(), key);
        if (oldExchange == null) {
            DefaultExchangeHolder holder = DefaultExchangeHolder.marshal(newExchange, true, allowSerializedHeaders);
            final DefaultExchangeHolder misbehaviorHolder = cache.putIfAbsent(key, holder);
            if (misbehaviorHolder != null) {
                Exchange misbehaviorEx = unmarshallExchange(camelContext, misbehaviorHolder);
                LOG.warn(
                        "Optimistic locking failed for exchange with key {}: IMap#putIfAbsend returned Exchange with ID {}, while it's expected no exchanges to be returned",
                        key, misbehaviorEx != null ? misbehaviorEx.getExchangeId() : "<null>");
                throw new OptimisticLockingException();
            }
        } else {
            DefaultExchangeHolder oldHolder = DefaultExchangeHolder.marshal(oldExchange, true, allowSerializedHeaders);
            DefaultExchangeHolder newHolder = DefaultExchangeHolder.marshal(newExchange, true, allowSerializedHeaders);
            if (!cache.replace(key, oldHolder, newHolder)) {
                LOG.warn(
                        "Optimistic locking failed for exchange with key {}: IMap#replace returned no Exchanges, while it's expected to replace one",
                        key);
                throw new OptimisticLockingException();
            }
        }
        LOG.trace("Added an Exchange with ID {} for key {} in optimistic manner.", newExchange.getExchangeId(), key);
        return oldExchange;
    }

    public Exchange add(CamelContext camelContext, String key, Exchange oldExchange, Exchange newExchange)
            throws OptimisticLockingException {
        if (!optimistic) {
            throw new UnsupportedOperationException();
        }

        LOG.trace("Adding an Exchange with ID {} for key {} in an optimistic manner.", newExchange.getExchangeId(), key);
        if (oldExchange == null) {
            DefaultExchangeHolder newHolder = DefaultExchangeHolder.marshal(newExchange, true, allowSerializedHeaders);
            DefaultExchangeHolder oldHolder = cache.getAndPut(key, newHolder);
            if (oldHolder != null) {
                Exchange exchange = unmarshallExchange(camelContext, oldHolder);
                LOG.error(
                        "Optimistic locking failed for exchange with key {}: IMap#putIfAbsend returned Exchange with ID {}, while it's expected no exchanges to be returned",
                        key,
                        exchange != null ? exchange.getExchangeId() : "<null>");

                throw new OptimisticLockingException();
            }
        } else {
            DefaultExchangeHolder oldHolder = DefaultExchangeHolder.marshal(oldExchange, true, allowSerializedHeaders);
            DefaultExchangeHolder newHolder = DefaultExchangeHolder.marshal(newExchange, true, allowSerializedHeaders);
            if (!cache.replace(key, oldHolder, newHolder)) {
                LOG.error(
                        "Optimistic locking failed for exchange with key {}: IMap#replace returned no Exchanges, while it's expected to replace one",
                        key);
                throw new OptimisticLockingException();
            }
        }
        LOG.trace("Added an Exchange with ID {} for key {} in optimistic manner.", newExchange.getExchangeId(), key);
        return oldExchange;
    }

    public Exchange add(CamelContext camelContext, String key, Exchange oldExchange, Exchange newExchange)
            throws OptimisticLockingException {
        if (!optimistic) {
            throw new UnsupportedOperationException();
        }
        LOG.trace("Adding an Exchange with ID {} for key {} in an optimistic manner.", newExchange.getExchangeId(), key);
        if (oldExchange == null) {
            DefaultExchangeHolder holder = DefaultExchangeHolder.marshal(newExchange, true, allowSerializedHeaders);
            final DefaultExchangeHolder misbehaviorHolder = cache.putIfAbsent(key, holder);
            if (misbehaviorHolder != null) {
                Exchange misbehaviorEx = unmarshallExchange(camelContext, misbehaviorHolder);
                LOG.error(
                        "Optimistic locking failed for exchange with key {}: IMap#putIfAbsend returned Exchange with ID {}, while it's expected no exchanges to be returned",
                        key, misbehaviorEx != null ? misbehaviorEx.getExchangeId() : "<null>");
                throw new OptimisticLockingException();
            }
        } else {
            DefaultExchangeHolder oldHolder = DefaultExchangeHolder.marshal(oldExchange, true, allowSerializedHeaders);
            DefaultExchangeHolder newHolder = DefaultExchangeHolder.marshal(newExchange, true, allowSerializedHeaders);
            if (!cache.replace(key, oldHolder, newHolder)) {
                LOG.error(
                        "Optimistic locking failed for exchange with key {}: IMap#replace returned no Exchanges, while it's expected to replace one",
                        key);
                throw new OptimisticLockingException();
            }
        }
        LOG.trace("Added an Exchange with ID {} for key {} in optimistic manner.", newExchange.getExchangeId(), key);
        return oldExchange;
    }

    public Exchange add(CamelContext camelContext, String key, Exchange oldExchange, Exchange newExchange)
            throws OptimisticLockingException {
        if (!optimistic) {
            throw new UnsupportedOperationException();
        }
        LOG.trace("Adding an Exchange with ID {} for key {} in an optimistic manner.", newExchange.getExchangeId(), key);
        if (oldExchange == null) {
            DefaultExchangeHolder holder = DefaultExchangeHolder.marshal(newExchange, true, allowSerializedHeaders);
            final DefaultExchangeHolder misbehaviorHolder = replicatedCache.putIfAbsent(key, holder);
            if (misbehaviorHolder != null) {
                Exchange misbehaviorEx = unmarshallExchange(camelContext, misbehaviorHolder);
                LOG.error(
                        "Optimistic locking failed for exchange with key {}: IMap#putIfAbsend returned Exchange with ID {}, while it's expected no exchanges to be returned",
                        key, misbehaviorEx != null ? misbehaviorEx.getExchangeId() : "<null>");
                throw new OptimisticLockingException();
            }
        } else {
            DefaultExchangeHolder oldHolder = DefaultExchangeHolder.marshal(oldExchange, true, allowSerializedHeaders);
            DefaultExchangeHolder newHolder = DefaultExchangeHolder.marshal(newExchange, true, allowSerializedHeaders);
            if (!replicatedCache.replace(key, oldHolder, newHolder)) {
                LOG.error(
                        "Optimistic locking failed for exchange with key {}: IMap#replace returned no Exchanges, while it's expected to replace one",
                        key);
                throw new OptimisticLockingException();
            }
        }
        LOG.trace("Added an Exchange with ID {} for key {} in optimistic manner.", newExchange.getExchangeId(), key);
        return oldExchange;
    }

    public Exchange add(CamelContext camelContext, String key, Exchange oldExchange, Exchange newExchange)
            throws OptimisticLockingException {
        if (!optimistic) {
            throw new UnsupportedOperationException();
        }
        LOG.trace("Adding an Exchange with ID {} for key {} in an optimistic manner.", newExchange.getExchangeId(), key);
        if (oldExchange == null) {
            DefaultExchangeHolder holder = DefaultExchangeHolder.marshal(newExchange, true, allowSerializedHeaders);
            final DefaultExchangeHolder misbehaviorHolder = cache.putIfAbsent(key, holder);
            if (misbehaviorHolder != null) {
                Exchange misbehaviorEx = unmarshallExchange(camelContext, misbehaviorHolder);
                LOG.warn(
                        "Optimistic locking failed for exchange with key {}: IMap#putIfAbsend returned Exchange with ID {}, while it's expected no exchanges to be returned",
                        key, misbehaviorEx != null ? misbehaviorEx.getExchangeId() : "<null>");
                throw new OptimisticLockingException();
            }
        } else {
            DefaultExchangeHolder oldHolder = DefaultExchangeHolder.marshal(oldExchange, true, allowSerializedHeaders);
            DefaultExchangeHolder newHolder = DefaultExchangeHolder.marshal(newExchange, true, allowSerializedHeaders);
            if (!cache.replace(key, oldHolder, newHolder)) {
                LOG.warn(
                        "Optimistic locking failed for exchange with key {}: IMap#replace returned no Exchanges, while it's expected to replace one",
                        key);
                throw new OptimisticLockingException();
            }
        }
        LOG.trace("Added an Exchange with ID {} for key {} in optimistic manner.", newExchange.getExchangeId(), key);
        return oldExchange;
    }

    public Exchange add(CamelContext camelContext, String key, Exchange oldExchange, Exchange newExchange)
            throws OptimisticLockingException {
        if (!optimistic) {
            throw new UnsupportedOperationException();
        }
        LOG.trace("Adding an Exchange with ID {} for key {} in an optimistic manner.", newExchange.getExchangeId(), key);
        if (oldExchange == null) {
            DefaultExchangeHolder holder = DefaultExchangeHolder.marshal(newExchange, true, allowSerializedHeaders);
            final DefaultExchangeHolder misbehaviorHolder = replicatedCache.putIfAbsent(key, holder);
            if (misbehaviorHolder != null) {
                Exchange misbehaviorEx = unmarshallExchange(camelContext, misbehaviorHolder);
                LOG.error(
                        "Optimistic locking failed for exchange with key {}: IMap#putIfAbsend returned Exchange with ID {}, while it's expected no exchanges to be returned",
                        key, misbehaviorEx != null ? misbehaviorEx.getExchangeId() : "<null>");
                throw new OptimisticLockingException();
            }
        } else {
            DefaultExchangeHolder oldHolder = DefaultExchangeHolder.marshal(oldExchange, true, allowSerializedHeaders);
            DefaultExchangeHolder newHolder = DefaultExchangeHolder.marshal(newExchange, true, allowSerializedHeaders);
            if (!replicatedCache.replace(key, oldHolder, newHolder)) {
                LOG.error(
                        "Optimistic locking failed for exchange with key {}: IMap#replace returned no Exchanges, while it's expected to replace one",
                        key);
                throw new OptimisticLockingException();
            }
        }
        LOG.trace("Added an Exchange with ID {} for key {} in optimistic manner.", newExchange.getExchangeId(), key);
        return oldExchange;
    }

    public Exchange add(CamelContext camelContext, String key, Exchange oldExchange, Exchange newExchange)
            throws OptimisticLockingException {
        if (!optimistic) {
            throw new UnsupportedOperationException();
        }
        LOG.trace("Adding an Exchange with ID {} for key {} in an optimistic manner.", newExchange.getExchangeId(), key);
        if (oldExchange == null) {
            DefaultExchangeHolder holder = DefaultExchangeHolder.marshal(newExchange, true, allowSerializedHeaders);
            final DefaultExchangeHolder misbehaviorHolder = cache.putIfAbsent(key, holder);
            if (misbehaviorHolder != null) {
                Exchange misbehaviorEx = unmarshallExchange(camelContext, misbehaviorHolder);
                LOG.error(
                        "Optimistic locking failed for exchange with key {}: IMap#putIfAbsend returned Exchange with ID {}, while it's expected no exchanges to be returned",
                        key, misbehaviorEx != null ? misbehaviorEx.getExchangeId() : "<null>");
                throw new OptimisticLockingException();
            }
        } else {
            DefaultExchangeHolder oldHolder = DefaultExchangeHolder.marshal(oldExchange, true, allowSerializedHeaders);
            DefaultExchangeHolder newHolder = DefaultExchangeHolder.marshal(newExchange, true, allowSerializedHeaders);
            if (!cache.replace(key, oldHolder, newHolder)) {
                LOG.error(
                        "Optimistic locking failed for exchange with key {}: IMap#replace returned no Exchanges, while it's expected to replace one",
                        key);
                throw new OptimisticLockingException();
            }
        }
        LOG.trace("Added an Exchange with ID {} for key {} in optimistic manner.", newExchange.getExchangeId(), key);
        return oldExchange;
    }

    public Exchange add(CamelContext camelContext, String key, Exchange oldExchange, Exchange newExchange)
            throws OptimisticLockingException {
        if (!optimistic) {
            throw new UnsupportedOperationException();
        }
        LOG.trace("Adding an Exchange with ID {} for key {} in an optimistic manner.", newExchange.getExchangeId(), key);
        if (oldExchange == null) {
            DefaultExchangeHolder holder = DefaultExchangeHolder.marshal(newExchange, true, allowSerializedHeaders);
            final DefaultExchangeHolder misbehaviorHolder = cache.putIfAbsent(key, holder);
            if (misbehaviorHolder != null) {
                Exchange misbehaviorEx = unmarshallExchange(camelContext, misbehaviorHolder);
                LOG.warn(
                        "Optimistic locking failed for exchange with key {}: IMap#putIfAbsend returned Exchange with ID {}, while it's expected no exchanges to be returned",
                        key, misbehaviorEx != null ? misbehaviorEx.getExchangeId() : "<null>");
                throw new OptimisticLockingException();
            }
        } else {
            DefaultExchangeHolder oldHolder = DefaultExchangeHolder.marshal(oldExchange, true, allowSerializedHeaders);
            DefaultExchangeHolder newHolder = DefaultExchangeHolder.marshal(newExchange, true, allowSerializedHeaders);
            if (!cache.replace(key, oldHolder, newHolder)) {
                LOG.warn(
                        "Optimistic locking failed for exchange with key {}: IMap#replace returned no Exchanges, while it's expected to replace one",
                        key);
                throw new OptimisticLockingException();
            }
        }
        LOG.trace("Added an Exchange with ID {} for key {} in optimistic manner.", newExchange.getExchangeId(), key);
        return oldExchange;
    }

    public Exchange add(CamelContext camelContext, String key, Exchange oldExchange, Exchange newExchange)
            throws OptimisticLockingException {
        if (!optimistic) {
            throw new UnsupportedOperationException();
        }
        LOG.trace("Adding an Exchange with ID {} for key {} in an optimistic manner.", newExchange.getExchangeId(), key);
        if (oldExchange == null) {
            DefaultExchangeHolder holder = DefaultExchangeHolder.marshal(newExchange, true, allowSerializedHeaders);
            final DefaultExchangeHolder misbehaviorHolder = cache.putIfAbsent(key, holder);
            if (misbehaviorHolder != null) {
                Exchange misbehaviorEx = unmarshallExchange(camelContext, misbehaviorHolder);
                LOG.error(
                        "Optimistic locking failed for exchange with key {}: IMap#putIfAbsend returned Exchange with ID {}, while it's expected no exchanges to be returned",
                        key, misbehaviorEx != null ? misbehaviorEx.getExchangeId() : "<null>");
                throw new OptimisticLockingException();
            }
        } else {
            DefaultExchangeHolder oldHolder = DefaultExchangeHolder.marshal(oldExchange, true, allowSerializedHeaders);
            DefaultExchangeHolder newHolder = DefaultExchangeHolder.marshal(newExchange, true, allowSerializedHeaders);
            if (!cache.replace(key, oldHolder, newHolder)) {
                LOG.error(
                        "Optimistic locking failed for exchange with key {}: IMap#replace returned no Exchanges, while it's expected to replace one",
                        key);
                throw new OptimisticLockingException();
            }
        }
        LOG.trace("Added an Exchange with ID {} for key {} in optimistic manner.", newExchange.getExchangeId(), key);
        return oldExchange;
    }

    private void validateRoles(String accessToken, Exchange exchange) throws Exception {
        try {
            Set<String> userRoles;

             
            if (policy.isUseTokenIntrospection() && policy.getTokenIntrospector() != null) {
                KeycloakTokenIntrospector.IntrospectionResult introspectionResult
                        = KeycloakSecurityHelper.introspectToken(accessToken, policy.getTokenIntrospector());

                 
                if (!introspectionResult.isActive()) {
                    throw new CamelAuthorizationException("Token is not active (may be revoked or expired)", exchange);
                }

                userRoles = KeycloakSecurityHelper.extractRolesFromIntrospection(
                        introspectionResult, policy.getRealm(), policy.getClientId());
            } else {
                 
                AccessToken token;
                if (ObjectHelper.isEmpty(policy.getPublicKey())) {
                    token = KeycloakSecurityHelper.parseAccessToken(accessToken);
                } else {
                    token = KeycloakSecurityHelper.parseAccessToken(accessToken, policy.getPublicKey());
                }
                userRoles = KeycloakSecurityHelper.extractRoles(token, policy.getRealm(), policy.getClientId());
            }

            boolean hasRequiredRoles = policy.isAllRolesRequired()
                    ? userRoles.containsAll(policy.getRequiredRolesAsList())
                    : policy.getRequiredRolesAsList().stream().anyMatch(userRoles::contains);

            if (!hasRequiredRoles) {
                String message = String.format("User does not have required roles. Required: %s, User has: %s",
                        policy.getRequiredRoles(), userRoles);
                LOG.debug(message);
                throw new CamelAuthorizationException(message, exchange);
            }

            LOG.debug("Role validation successful for user with roles: {}", userRoles);

        } catch (Exception e) {
            if (e instanceof CamelAuthorizationException) {
                throw e;
            }
            throw new CamelAuthorizationException("Failed to validate roles", exchange, e);
        }
    }

    private void validatePermissions(String accessToken, Exchange exchange) throws Exception {
        try {
            Set<String> userPermissions;

             
            if (policy.isUseTokenIntrospection() && policy.getTokenIntrospector() != null) {
                KeycloakTokenIntrospector.IntrospectionResult introspectionResult
                        = KeycloakSecurityHelper.introspectToken(accessToken, policy.getTokenIntrospector());

                 
                if (!introspectionResult.isActive()) {
                    throw new CamelAuthorizationException("Token is not active (may be revoked or expired)", exchange);
                }

                userPermissions = KeycloakSecurityHelper.extractPermissionsFromIntrospection(introspectionResult);
            } else {
                 
                AccessToken token;
                if (ObjectHelper.isEmpty(policy.getPublicKey())) {
                    token = KeycloakSecurityHelper.parseAccessToken(accessToken);
                } else {
                    token = KeycloakSecurityHelper.parseAccessToken(accessToken, policy.getPublicKey());
                }
                userPermissions = KeycloakSecurityHelper.extractPermissions(token);
            }

            boolean hasRequiredPermissions = policy.isAllPermissionsRequired()
                    ? userPermissions.containsAll(policy.getRequiredPermissionsAsList())
                    : policy.getRequiredPermissionsAsList().stream().anyMatch(userPermissions::contains);

            if (!hasRequiredPermissions) {
                String message = String.format("User does not have required permissions. Required: %s, User has: %s",
                        policy.getRequiredPermissions(), userPermissions);
                LOG.debug(message);
                throw new CamelAuthorizationException(message, exchange);
            }

            LOG.debug("Permission validation successful for user with permissions: {}", userPermissions);

        } catch (Exception e) {
            if (e instanceof CamelAuthorizationException) {
                throw e;
            }
            throw new CamelAuthorizationException("Failed to validate permissions", exchange, e);
        }
    }

    private void updateRealm(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RealmRepresentation) {
                keycloakClient.realm(realmName).update((RealmRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Realm updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update realm requires POJO request with RealmRepresentation");
        }
    }

    private void updateClient(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).update((ClientRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client requires POJO request with ClientRepresentation");
        }
    }

    private void updateRealm(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RealmRepresentation) {
                keycloakClient.realm(realmName).update((RealmRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Realm updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update realm requires POJO request with RealmRepresentation");
        }
    }

    private void updateIdentityProvider(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String idpAlias = exchange.getIn().getHeader(KeycloakConstants.IDP_ALIAS, String.class);
        if (ObjectHelper.isEmpty(idpAlias)) {
            throw new IllegalArgumentException("Identity provider alias must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof IdentityProviderRepresentation) {
                keycloakClient.realm(realmName).identityProviders().get(idpAlias)
                        .update((IdentityProviderRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Identity provider updated successfully");
            }
        } else {
            throw new IllegalArgumentException(
                    "Update identity provider requires POJO request with IdentityProviderRepresentation");
        }
    }

    private void updateRealm(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RealmRepresentation) {
                keycloakClient.realm(realmName).update((RealmRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Realm updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update realm requires POJO request with RealmRepresentation");
        }
    }

    private void updateGroup(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String groupId = exchange.getIn().getHeader(KeycloakConstants.GROUP_ID, String.class);
        if (ObjectHelper.isEmpty(groupId)) {
            throw new IllegalArgumentException(MISSING_GROUP_ID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof GroupRepresentation) {
                keycloakClient.realm(realmName).groups().group(groupId).update((GroupRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Group updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update group requires POJO request with GroupRepresentation");
        }
    }

    private void updateRealm(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RealmRepresentation) {
                keycloakClient.realm(realmName).update((RealmRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Realm updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update realm requires POJO request with RealmRepresentation");
        }
    }

    private void createIdentityProvider(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof IdentityProviderRepresentation) {
                Response response
                        = keycloakClient.realm(realmName).identityProviders().create((IdentityProviderRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException(
                    "Create identity provider requires POJO request with IdentityProviderRepresentation");
        }
    }

    private void updateRealm(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RealmRepresentation) {
                keycloakClient.realm(realmName).update((RealmRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Realm updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update realm requires POJO request with RealmRepresentation");
        }
    }

    private void updateRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
        if (ObjectHelper.isEmpty(roleName)) {
            throw new IllegalArgumentException(MISSING_ROLE_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).roles().get(roleName).update((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Role updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update role requires POJO request with RoleRepresentation");
        }
    }

    private void updateRealm(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RealmRepresentation) {
                keycloakClient.realm(realmName).update((RealmRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Realm updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update realm requires POJO request with RealmRepresentation");
        }
    }

    private void updateClientScope(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientScopeId = exchange.getIn().getHeader(KeycloakConstants.CLIENT_SCOPE_ID, String.class);
        if (ObjectHelper.isEmpty(clientScopeId)) {
            throw new IllegalArgumentException("Client scope ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientScopeRepresentation) {
                keycloakClient.realm(realmName).clientScopes().get(clientScopeId).update((ClientScopeRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client scope updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client scope requires POJO request with ClientScopeRepresentation");
        }
    }

    private void updateRealm(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RealmRepresentation) {
                keycloakClient.realm(realmName).update((RealmRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Realm updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update realm requires POJO request with RealmRepresentation");
        }
    }

    private void updateUser(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String userId = exchange.getIn().getHeader(KeycloakConstants.USER_ID, String.class);
        if (ObjectHelper.isEmpty(userId)) {
            throw new IllegalArgumentException(MISSING_USER_ID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof UserRepresentation) {
                keycloakClient.realm(realmName).users().get(userId).update((UserRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("User updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update user requires POJO request with UserRepresentation");
        }
    }

    private void updateRealm(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RealmRepresentation) {
                keycloakClient.realm(realmName).update((RealmRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Realm updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update realm requires POJO request with RealmRepresentation");
        }
    }

    private void createResource(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourceRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().resources()
                        .create((ResourceRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create resource requires POJO request with ResourceRepresentation");
        }
    }

    private void updateRealm(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RealmRepresentation) {
                keycloakClient.realm(realmName).update((RealmRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Realm updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update realm requires POJO request with RealmRepresentation");
        }
    }

    private void createResourcePolicy(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies()
                        .create((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create policy requires POJO request with PolicyRepresentation");
        }
    }

    private void updateRealm(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RealmRepresentation) {
                keycloakClient.realm(realmName).update((RealmRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Realm updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update realm requires POJO request with RealmRepresentation");
        }
    }

    private void createResourcePermission(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourcePermissionRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().permissions()
                        .resource().create((ResourcePermissionRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create permission requires POJO request with ResourcePermissionRepresentation");
        }
    }

    private void updateRealm(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RealmRepresentation) {
                keycloakClient.realm(realmName).update((RealmRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Realm updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update realm requires POJO request with RealmRepresentation");
        }
    }

    private void updateResourcePermission(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String permissionId = exchange.getIn().getHeader(KeycloakConstants.PERMISSION_ID, String.class);
        if (ObjectHelper.isEmpty(permissionId)) {
            throw new IllegalArgumentException("Permission ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                 
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies().policy(permissionId)
                        .update((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Permission updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update permission requires POJO request with PolicyRepresentation");
        }
    }

    private void updateRealm(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RealmRepresentation) {
                keycloakClient.realm(realmName).update((RealmRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Realm updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update realm requires POJO request with RealmRepresentation");
        }
    }

    private void updateClientRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
        if (ObjectHelper.isEmpty(roleName)) {
            throw new IllegalArgumentException(MISSING_ROLE_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).roles().get(roleName)
                        .update((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client role updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client role requires POJO request with RoleRepresentation");
        }
    }

    private void updateRealm(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RealmRepresentation) {
                keycloakClient.realm(realmName).update((RealmRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Realm updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update realm requires POJO request with RealmRepresentation");
        }
    }

    private void updateResource(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String resourceId = exchange.getIn().getHeader(KeycloakConstants.RESOURCE_ID, String.class);
        if (ObjectHelper.isEmpty(resourceId)) {
            throw new IllegalArgumentException("Resource ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourceRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().resources().resource(resourceId)
                        .update((ResourceRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Resource updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update resource requires POJO request with ResourceRepresentation");
        }
    }

    private void updateRealm(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RealmRepresentation) {
                keycloakClient.realm(realmName).update((RealmRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Realm updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update realm requires POJO request with RealmRepresentation");
        }
    }

    private void updateResourcePolicy(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String policyId = exchange.getIn().getHeader(KeycloakConstants.POLICY_ID, String.class);
        if (ObjectHelper.isEmpty(policyId)) {
            throw new IllegalArgumentException("Policy ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies().policy(policyId)
                        .update((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Policy updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update policy requires POJO request with PolicyRepresentation");
        }
    }

    private void updateClient(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).update((ClientRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client requires POJO request with ClientRepresentation");
        }
    }

    private void updateIdentityProvider(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String idpAlias = exchange.getIn().getHeader(KeycloakConstants.IDP_ALIAS, String.class);
        if (ObjectHelper.isEmpty(idpAlias)) {
            throw new IllegalArgumentException("Identity provider alias must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof IdentityProviderRepresentation) {
                keycloakClient.realm(realmName).identityProviders().get(idpAlias)
                        .update((IdentityProviderRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Identity provider updated successfully");
            }
        } else {
            throw new IllegalArgumentException(
                    "Update identity provider requires POJO request with IdentityProviderRepresentation");
        }
    }

    private void updateClient(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).update((ClientRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client requires POJO request with ClientRepresentation");
        }
    }

    private void updateGroup(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String groupId = exchange.getIn().getHeader(KeycloakConstants.GROUP_ID, String.class);
        if (ObjectHelper.isEmpty(groupId)) {
            throw new IllegalArgumentException(MISSING_GROUP_ID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof GroupRepresentation) {
                keycloakClient.realm(realmName).groups().group(groupId).update((GroupRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Group updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update group requires POJO request with GroupRepresentation");
        }
    }

    private void updateClient(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).update((ClientRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client requires POJO request with ClientRepresentation");
        }
    }

    private void createIdentityProvider(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof IdentityProviderRepresentation) {
                Response response
                        = keycloakClient.realm(realmName).identityProviders().create((IdentityProviderRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException(
                    "Create identity provider requires POJO request with IdentityProviderRepresentation");
        }
    }

    private void updateClient(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).update((ClientRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client requires POJO request with ClientRepresentation");
        }
    }

    private void updateRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
        if (ObjectHelper.isEmpty(roleName)) {
            throw new IllegalArgumentException(MISSING_ROLE_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).roles().get(roleName).update((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Role updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update role requires POJO request with RoleRepresentation");
        }
    }

    private void updateClient(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).update((ClientRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client requires POJO request with ClientRepresentation");
        }
    }

    private void updateClientScope(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientScopeId = exchange.getIn().getHeader(KeycloakConstants.CLIENT_SCOPE_ID, String.class);
        if (ObjectHelper.isEmpty(clientScopeId)) {
            throw new IllegalArgumentException("Client scope ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientScopeRepresentation) {
                keycloakClient.realm(realmName).clientScopes().get(clientScopeId).update((ClientScopeRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client scope updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client scope requires POJO request with ClientScopeRepresentation");
        }
    }

    private void updateClient(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).update((ClientRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client requires POJO request with ClientRepresentation");
        }
    }

    private void updateUser(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String userId = exchange.getIn().getHeader(KeycloakConstants.USER_ID, String.class);
        if (ObjectHelper.isEmpty(userId)) {
            throw new IllegalArgumentException(MISSING_USER_ID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof UserRepresentation) {
                keycloakClient.realm(realmName).users().get(userId).update((UserRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("User updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update user requires POJO request with UserRepresentation");
        }
    }

    private void updateClient(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).update((ClientRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client requires POJO request with ClientRepresentation");
        }
    }

    private void createResource(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourceRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().resources()
                        .create((ResourceRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create resource requires POJO request with ResourceRepresentation");
        }
    }

    private void updateClient(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).update((ClientRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client requires POJO request with ClientRepresentation");
        }
    }

    private void createResourcePolicy(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies()
                        .create((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create policy requires POJO request with PolicyRepresentation");
        }
    }

    private void updateClient(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).update((ClientRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client requires POJO request with ClientRepresentation");
        }
    }

    private void createResourcePermission(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourcePermissionRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().permissions()
                        .resource().create((ResourcePermissionRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create permission requires POJO request with ResourcePermissionRepresentation");
        }
    }

    private void updateClient(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).update((ClientRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client requires POJO request with ClientRepresentation");
        }
    }

    private void updateResourcePermission(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String permissionId = exchange.getIn().getHeader(KeycloakConstants.PERMISSION_ID, String.class);
        if (ObjectHelper.isEmpty(permissionId)) {
            throw new IllegalArgumentException("Permission ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                 
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies().policy(permissionId)
                        .update((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Permission updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update permission requires POJO request with PolicyRepresentation");
        }
    }

    private void updateClient(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).update((ClientRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client requires POJO request with ClientRepresentation");
        }
    }

    private void updateClientRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
        if (ObjectHelper.isEmpty(roleName)) {
            throw new IllegalArgumentException(MISSING_ROLE_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).roles().get(roleName)
                        .update((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client role updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client role requires POJO request with RoleRepresentation");
        }
    }

    private void updateClient(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).update((ClientRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client requires POJO request with ClientRepresentation");
        }
    }

    private void updateResource(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String resourceId = exchange.getIn().getHeader(KeycloakConstants.RESOURCE_ID, String.class);
        if (ObjectHelper.isEmpty(resourceId)) {
            throw new IllegalArgumentException("Resource ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourceRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().resources().resource(resourceId)
                        .update((ResourceRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Resource updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update resource requires POJO request with ResourceRepresentation");
        }
    }

    private void updateClient(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).update((ClientRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client requires POJO request with ClientRepresentation");
        }
    }

    private void updateResourcePolicy(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String policyId = exchange.getIn().getHeader(KeycloakConstants.POLICY_ID, String.class);
        if (ObjectHelper.isEmpty(policyId)) {
            throw new IllegalArgumentException("Policy ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies().policy(policyId)
                        .update((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Policy updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update policy requires POJO request with PolicyRepresentation");
        }
    }

    private void updateIdentityProvider(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String idpAlias = exchange.getIn().getHeader(KeycloakConstants.IDP_ALIAS, String.class);
        if (ObjectHelper.isEmpty(idpAlias)) {
            throw new IllegalArgumentException("Identity provider alias must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof IdentityProviderRepresentation) {
                keycloakClient.realm(realmName).identityProviders().get(idpAlias)
                        .update((IdentityProviderRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Identity provider updated successfully");
            }
        } else {
            throw new IllegalArgumentException(
                    "Update identity provider requires POJO request with IdentityProviderRepresentation");
        }
    }

    private void updateGroup(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String groupId = exchange.getIn().getHeader(KeycloakConstants.GROUP_ID, String.class);
        if (ObjectHelper.isEmpty(groupId)) {
            throw new IllegalArgumentException(MISSING_GROUP_ID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof GroupRepresentation) {
                keycloakClient.realm(realmName).groups().group(groupId).update((GroupRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Group updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update group requires POJO request with GroupRepresentation");
        }
    }

    private void updateIdentityProvider(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String idpAlias = exchange.getIn().getHeader(KeycloakConstants.IDP_ALIAS, String.class);
        if (ObjectHelper.isEmpty(idpAlias)) {
            throw new IllegalArgumentException("Identity provider alias must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof IdentityProviderRepresentation) {
                keycloakClient.realm(realmName).identityProviders().get(idpAlias)
                        .update((IdentityProviderRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Identity provider updated successfully");
            }
        } else {
            throw new IllegalArgumentException(
                    "Update identity provider requires POJO request with IdentityProviderRepresentation");
        }
    }

    private void createIdentityProvider(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof IdentityProviderRepresentation) {
                Response response
                        = keycloakClient.realm(realmName).identityProviders().create((IdentityProviderRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException(
                    "Create identity provider requires POJO request with IdentityProviderRepresentation");
        }
    }

    private void updateIdentityProvider(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String idpAlias = exchange.getIn().getHeader(KeycloakConstants.IDP_ALIAS, String.class);
        if (ObjectHelper.isEmpty(idpAlias)) {
            throw new IllegalArgumentException("Identity provider alias must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof IdentityProviderRepresentation) {
                keycloakClient.realm(realmName).identityProviders().get(idpAlias)
                        .update((IdentityProviderRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Identity provider updated successfully");
            }
        } else {
            throw new IllegalArgumentException(
                    "Update identity provider requires POJO request with IdentityProviderRepresentation");
        }
    }

    private void updateRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
        if (ObjectHelper.isEmpty(roleName)) {
            throw new IllegalArgumentException(MISSING_ROLE_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).roles().get(roleName).update((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Role updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update role requires POJO request with RoleRepresentation");
        }
    }

    private void updateIdentityProvider(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String idpAlias = exchange.getIn().getHeader(KeycloakConstants.IDP_ALIAS, String.class);
        if (ObjectHelper.isEmpty(idpAlias)) {
            throw new IllegalArgumentException("Identity provider alias must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof IdentityProviderRepresentation) {
                keycloakClient.realm(realmName).identityProviders().get(idpAlias)
                        .update((IdentityProviderRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Identity provider updated successfully");
            }
        } else {
            throw new IllegalArgumentException(
                    "Update identity provider requires POJO request with IdentityProviderRepresentation");
        }
    }

    private void updateClientScope(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientScopeId = exchange.getIn().getHeader(KeycloakConstants.CLIENT_SCOPE_ID, String.class);
        if (ObjectHelper.isEmpty(clientScopeId)) {
            throw new IllegalArgumentException("Client scope ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientScopeRepresentation) {
                keycloakClient.realm(realmName).clientScopes().get(clientScopeId).update((ClientScopeRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client scope updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client scope requires POJO request with ClientScopeRepresentation");
        }
    }

    private void updateIdentityProvider(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String idpAlias = exchange.getIn().getHeader(KeycloakConstants.IDP_ALIAS, String.class);
        if (ObjectHelper.isEmpty(idpAlias)) {
            throw new IllegalArgumentException("Identity provider alias must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof IdentityProviderRepresentation) {
                keycloakClient.realm(realmName).identityProviders().get(idpAlias)
                        .update((IdentityProviderRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Identity provider updated successfully");
            }
        } else {
            throw new IllegalArgumentException(
                    "Update identity provider requires POJO request with IdentityProviderRepresentation");
        }
    }

    private void updateUser(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String userId = exchange.getIn().getHeader(KeycloakConstants.USER_ID, String.class);
        if (ObjectHelper.isEmpty(userId)) {
            throw new IllegalArgumentException(MISSING_USER_ID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof UserRepresentation) {
                keycloakClient.realm(realmName).users().get(userId).update((UserRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("User updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update user requires POJO request with UserRepresentation");
        }
    }

    private void updateIdentityProvider(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String idpAlias = exchange.getIn().getHeader(KeycloakConstants.IDP_ALIAS, String.class);
        if (ObjectHelper.isEmpty(idpAlias)) {
            throw new IllegalArgumentException("Identity provider alias must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof IdentityProviderRepresentation) {
                keycloakClient.realm(realmName).identityProviders().get(idpAlias)
                        .update((IdentityProviderRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Identity provider updated successfully");
            }
        } else {
            throw new IllegalArgumentException(
                    "Update identity provider requires POJO request with IdentityProviderRepresentation");
        }
    }

    private void createResource(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourceRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().resources()
                        .create((ResourceRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create resource requires POJO request with ResourceRepresentation");
        }
    }

    private void updateIdentityProvider(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String idpAlias = exchange.getIn().getHeader(KeycloakConstants.IDP_ALIAS, String.class);
        if (ObjectHelper.isEmpty(idpAlias)) {
            throw new IllegalArgumentException("Identity provider alias must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof IdentityProviderRepresentation) {
                keycloakClient.realm(realmName).identityProviders().get(idpAlias)
                        .update((IdentityProviderRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Identity provider updated successfully");
            }
        } else {
            throw new IllegalArgumentException(
                    "Update identity provider requires POJO request with IdentityProviderRepresentation");
        }
    }

    private void createResourcePolicy(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies()
                        .create((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create policy requires POJO request with PolicyRepresentation");
        }
    }

    private void updateIdentityProvider(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String idpAlias = exchange.getIn().getHeader(KeycloakConstants.IDP_ALIAS, String.class);
        if (ObjectHelper.isEmpty(idpAlias)) {
            throw new IllegalArgumentException("Identity provider alias must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof IdentityProviderRepresentation) {
                keycloakClient.realm(realmName).identityProviders().get(idpAlias)
                        .update((IdentityProviderRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Identity provider updated successfully");
            }
        } else {
            throw new IllegalArgumentException(
                    "Update identity provider requires POJO request with IdentityProviderRepresentation");
        }
    }

    private void createResourcePermission(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourcePermissionRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().permissions()
                        .resource().create((ResourcePermissionRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create permission requires POJO request with ResourcePermissionRepresentation");
        }
    }

    private void updateIdentityProvider(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String idpAlias = exchange.getIn().getHeader(KeycloakConstants.IDP_ALIAS, String.class);
        if (ObjectHelper.isEmpty(idpAlias)) {
            throw new IllegalArgumentException("Identity provider alias must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof IdentityProviderRepresentation) {
                keycloakClient.realm(realmName).identityProviders().get(idpAlias)
                        .update((IdentityProviderRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Identity provider updated successfully");
            }
        } else {
            throw new IllegalArgumentException(
                    "Update identity provider requires POJO request with IdentityProviderRepresentation");
        }
    }

    private void updateResourcePermission(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String permissionId = exchange.getIn().getHeader(KeycloakConstants.PERMISSION_ID, String.class);
        if (ObjectHelper.isEmpty(permissionId)) {
            throw new IllegalArgumentException("Permission ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                 
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies().policy(permissionId)
                        .update((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Permission updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update permission requires POJO request with PolicyRepresentation");
        }
    }

    private void updateIdentityProvider(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String idpAlias = exchange.getIn().getHeader(KeycloakConstants.IDP_ALIAS, String.class);
        if (ObjectHelper.isEmpty(idpAlias)) {
            throw new IllegalArgumentException("Identity provider alias must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof IdentityProviderRepresentation) {
                keycloakClient.realm(realmName).identityProviders().get(idpAlias)
                        .update((IdentityProviderRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Identity provider updated successfully");
            }
        } else {
            throw new IllegalArgumentException(
                    "Update identity provider requires POJO request with IdentityProviderRepresentation");
        }
    }

    private void updateClientRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
        if (ObjectHelper.isEmpty(roleName)) {
            throw new IllegalArgumentException(MISSING_ROLE_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).roles().get(roleName)
                        .update((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client role updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client role requires POJO request with RoleRepresentation");
        }
    }

    private void updateIdentityProvider(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String idpAlias = exchange.getIn().getHeader(KeycloakConstants.IDP_ALIAS, String.class);
        if (ObjectHelper.isEmpty(idpAlias)) {
            throw new IllegalArgumentException("Identity provider alias must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof IdentityProviderRepresentation) {
                keycloakClient.realm(realmName).identityProviders().get(idpAlias)
                        .update((IdentityProviderRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Identity provider updated successfully");
            }
        } else {
            throw new IllegalArgumentException(
                    "Update identity provider requires POJO request with IdentityProviderRepresentation");
        }
    }

    private void updateResource(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String resourceId = exchange.getIn().getHeader(KeycloakConstants.RESOURCE_ID, String.class);
        if (ObjectHelper.isEmpty(resourceId)) {
            throw new IllegalArgumentException("Resource ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourceRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().resources().resource(resourceId)
                        .update((ResourceRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Resource updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update resource requires POJO request with ResourceRepresentation");
        }
    }

    private void updateIdentityProvider(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String idpAlias = exchange.getIn().getHeader(KeycloakConstants.IDP_ALIAS, String.class);
        if (ObjectHelper.isEmpty(idpAlias)) {
            throw new IllegalArgumentException("Identity provider alias must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof IdentityProviderRepresentation) {
                keycloakClient.realm(realmName).identityProviders().get(idpAlias)
                        .update((IdentityProviderRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Identity provider updated successfully");
            }
        } else {
            throw new IllegalArgumentException(
                    "Update identity provider requires POJO request with IdentityProviderRepresentation");
        }
    }

    private void updateResourcePolicy(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String policyId = exchange.getIn().getHeader(KeycloakConstants.POLICY_ID, String.class);
        if (ObjectHelper.isEmpty(policyId)) {
            throw new IllegalArgumentException("Policy ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies().policy(policyId)
                        .update((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Policy updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update policy requires POJO request with PolicyRepresentation");
        }
    }

    private void updateGroup(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String groupId = exchange.getIn().getHeader(KeycloakConstants.GROUP_ID, String.class);
        if (ObjectHelper.isEmpty(groupId)) {
            throw new IllegalArgumentException(MISSING_GROUP_ID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof GroupRepresentation) {
                keycloakClient.realm(realmName).groups().group(groupId).update((GroupRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Group updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update group requires POJO request with GroupRepresentation");
        }
    }

    private void createIdentityProvider(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof IdentityProviderRepresentation) {
                Response response
                        = keycloakClient.realm(realmName).identityProviders().create((IdentityProviderRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException(
                    "Create identity provider requires POJO request with IdentityProviderRepresentation");
        }
    }

    private void updateGroup(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String groupId = exchange.getIn().getHeader(KeycloakConstants.GROUP_ID, String.class);
        if (ObjectHelper.isEmpty(groupId)) {
            throw new IllegalArgumentException(MISSING_GROUP_ID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof GroupRepresentation) {
                keycloakClient.realm(realmName).groups().group(groupId).update((GroupRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Group updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update group requires POJO request with GroupRepresentation");
        }
    }

    private void updateRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
        if (ObjectHelper.isEmpty(roleName)) {
            throw new IllegalArgumentException(MISSING_ROLE_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).roles().get(roleName).update((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Role updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update role requires POJO request with RoleRepresentation");
        }
    }

    private void updateGroup(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String groupId = exchange.getIn().getHeader(KeycloakConstants.GROUP_ID, String.class);
        if (ObjectHelper.isEmpty(groupId)) {
            throw new IllegalArgumentException(MISSING_GROUP_ID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof GroupRepresentation) {
                keycloakClient.realm(realmName).groups().group(groupId).update((GroupRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Group updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update group requires POJO request with GroupRepresentation");
        }
    }

    private void updateClientScope(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientScopeId = exchange.getIn().getHeader(KeycloakConstants.CLIENT_SCOPE_ID, String.class);
        if (ObjectHelper.isEmpty(clientScopeId)) {
            throw new IllegalArgumentException("Client scope ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientScopeRepresentation) {
                keycloakClient.realm(realmName).clientScopes().get(clientScopeId).update((ClientScopeRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client scope updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client scope requires POJO request with ClientScopeRepresentation");
        }
    }

    private void updateGroup(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String groupId = exchange.getIn().getHeader(KeycloakConstants.GROUP_ID, String.class);
        if (ObjectHelper.isEmpty(groupId)) {
            throw new IllegalArgumentException(MISSING_GROUP_ID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof GroupRepresentation) {
                keycloakClient.realm(realmName).groups().group(groupId).update((GroupRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Group updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update group requires POJO request with GroupRepresentation");
        }
    }

    private void updateUser(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String userId = exchange.getIn().getHeader(KeycloakConstants.USER_ID, String.class);
        if (ObjectHelper.isEmpty(userId)) {
            throw new IllegalArgumentException(MISSING_USER_ID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof UserRepresentation) {
                keycloakClient.realm(realmName).users().get(userId).update((UserRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("User updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update user requires POJO request with UserRepresentation");
        }
    }

    private void updateGroup(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String groupId = exchange.getIn().getHeader(KeycloakConstants.GROUP_ID, String.class);
        if (ObjectHelper.isEmpty(groupId)) {
            throw new IllegalArgumentException(MISSING_GROUP_ID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof GroupRepresentation) {
                keycloakClient.realm(realmName).groups().group(groupId).update((GroupRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Group updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update group requires POJO request with GroupRepresentation");
        }
    }

    private void createResource(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourceRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().resources()
                        .create((ResourceRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create resource requires POJO request with ResourceRepresentation");
        }
    }

    private void updateGroup(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String groupId = exchange.getIn().getHeader(KeycloakConstants.GROUP_ID, String.class);
        if (ObjectHelper.isEmpty(groupId)) {
            throw new IllegalArgumentException(MISSING_GROUP_ID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof GroupRepresentation) {
                keycloakClient.realm(realmName).groups().group(groupId).update((GroupRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Group updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update group requires POJO request with GroupRepresentation");
        }
    }

    private void createResourcePolicy(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies()
                        .create((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create policy requires POJO request with PolicyRepresentation");
        }
    }

    private void updateGroup(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String groupId = exchange.getIn().getHeader(KeycloakConstants.GROUP_ID, String.class);
        if (ObjectHelper.isEmpty(groupId)) {
            throw new IllegalArgumentException(MISSING_GROUP_ID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof GroupRepresentation) {
                keycloakClient.realm(realmName).groups().group(groupId).update((GroupRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Group updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update group requires POJO request with GroupRepresentation");
        }
    }

    private void createResourcePermission(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourcePermissionRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().permissions()
                        .resource().create((ResourcePermissionRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create permission requires POJO request with ResourcePermissionRepresentation");
        }
    }

    private void updateGroup(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String groupId = exchange.getIn().getHeader(KeycloakConstants.GROUP_ID, String.class);
        if (ObjectHelper.isEmpty(groupId)) {
            throw new IllegalArgumentException(MISSING_GROUP_ID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof GroupRepresentation) {
                keycloakClient.realm(realmName).groups().group(groupId).update((GroupRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Group updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update group requires POJO request with GroupRepresentation");
        }
    }

    private void updateResourcePermission(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String permissionId = exchange.getIn().getHeader(KeycloakConstants.PERMISSION_ID, String.class);
        if (ObjectHelper.isEmpty(permissionId)) {
            throw new IllegalArgumentException("Permission ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                 
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies().policy(permissionId)
                        .update((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Permission updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update permission requires POJO request with PolicyRepresentation");
        }
    }

    private void updateGroup(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String groupId = exchange.getIn().getHeader(KeycloakConstants.GROUP_ID, String.class);
        if (ObjectHelper.isEmpty(groupId)) {
            throw new IllegalArgumentException(MISSING_GROUP_ID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof GroupRepresentation) {
                keycloakClient.realm(realmName).groups().group(groupId).update((GroupRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Group updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update group requires POJO request with GroupRepresentation");
        }
    }

    private void updateClientRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
        if (ObjectHelper.isEmpty(roleName)) {
            throw new IllegalArgumentException(MISSING_ROLE_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).roles().get(roleName)
                        .update((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client role updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client role requires POJO request with RoleRepresentation");
        }
    }

    private void updateGroup(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String groupId = exchange.getIn().getHeader(KeycloakConstants.GROUP_ID, String.class);
        if (ObjectHelper.isEmpty(groupId)) {
            throw new IllegalArgumentException(MISSING_GROUP_ID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof GroupRepresentation) {
                keycloakClient.realm(realmName).groups().group(groupId).update((GroupRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Group updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update group requires POJO request with GroupRepresentation");
        }
    }

    private void updateResource(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String resourceId = exchange.getIn().getHeader(KeycloakConstants.RESOURCE_ID, String.class);
        if (ObjectHelper.isEmpty(resourceId)) {
            throw new IllegalArgumentException("Resource ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourceRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().resources().resource(resourceId)
                        .update((ResourceRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Resource updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update resource requires POJO request with ResourceRepresentation");
        }
    }

    private void updateGroup(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String groupId = exchange.getIn().getHeader(KeycloakConstants.GROUP_ID, String.class);
        if (ObjectHelper.isEmpty(groupId)) {
            throw new IllegalArgumentException(MISSING_GROUP_ID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof GroupRepresentation) {
                keycloakClient.realm(realmName).groups().group(groupId).update((GroupRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Group updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update group requires POJO request with GroupRepresentation");
        }
    }

    private void updateResourcePolicy(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String policyId = exchange.getIn().getHeader(KeycloakConstants.POLICY_ID, String.class);
        if (ObjectHelper.isEmpty(policyId)) {
            throw new IllegalArgumentException("Policy ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies().policy(policyId)
                        .update((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Policy updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update policy requires POJO request with PolicyRepresentation");
        }
    }

    private void createIdentityProvider(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof IdentityProviderRepresentation) {
                Response response
                        = keycloakClient.realm(realmName).identityProviders().create((IdentityProviderRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException(
                    "Create identity provider requires POJO request with IdentityProviderRepresentation");
        }
    }

    private void updateRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
        if (ObjectHelper.isEmpty(roleName)) {
            throw new IllegalArgumentException(MISSING_ROLE_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).roles().get(roleName).update((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Role updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update role requires POJO request with RoleRepresentation");
        }
    }

    private void createIdentityProvider(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof IdentityProviderRepresentation) {
                Response response
                        = keycloakClient.realm(realmName).identityProviders().create((IdentityProviderRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException(
                    "Create identity provider requires POJO request with IdentityProviderRepresentation");
        }
    }

    private void updateClientScope(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientScopeId = exchange.getIn().getHeader(KeycloakConstants.CLIENT_SCOPE_ID, String.class);
        if (ObjectHelper.isEmpty(clientScopeId)) {
            throw new IllegalArgumentException("Client scope ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientScopeRepresentation) {
                keycloakClient.realm(realmName).clientScopes().get(clientScopeId).update((ClientScopeRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client scope updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client scope requires POJO request with ClientScopeRepresentation");
        }
    }

    private void createIdentityProvider(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof IdentityProviderRepresentation) {
                Response response
                        = keycloakClient.realm(realmName).identityProviders().create((IdentityProviderRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException(
                    "Create identity provider requires POJO request with IdentityProviderRepresentation");
        }
    }

    private void updateUser(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String userId = exchange.getIn().getHeader(KeycloakConstants.USER_ID, String.class);
        if (ObjectHelper.isEmpty(userId)) {
            throw new IllegalArgumentException(MISSING_USER_ID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof UserRepresentation) {
                keycloakClient.realm(realmName).users().get(userId).update((UserRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("User updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update user requires POJO request with UserRepresentation");
        }
    }

    private void createIdentityProvider(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof IdentityProviderRepresentation) {
                Response response
                        = keycloakClient.realm(realmName).identityProviders().create((IdentityProviderRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException(
                    "Create identity provider requires POJO request with IdentityProviderRepresentation");
        }
    }

    private void createResource(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourceRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().resources()
                        .create((ResourceRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create resource requires POJO request with ResourceRepresentation");
        }
    }

    private void createIdentityProvider(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof IdentityProviderRepresentation) {
                Response response
                        = keycloakClient.realm(realmName).identityProviders().create((IdentityProviderRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException(
                    "Create identity provider requires POJO request with IdentityProviderRepresentation");
        }
    }

    private void createResourcePolicy(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies()
                        .create((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create policy requires POJO request with PolicyRepresentation");
        }
    }

    private void createIdentityProvider(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof IdentityProviderRepresentation) {
                Response response
                        = keycloakClient.realm(realmName).identityProviders().create((IdentityProviderRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException(
                    "Create identity provider requires POJO request with IdentityProviderRepresentation");
        }
    }

    private void createResourcePermission(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourcePermissionRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().permissions()
                        .resource().create((ResourcePermissionRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create permission requires POJO request with ResourcePermissionRepresentation");
        }
    }

    private void createIdentityProvider(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof IdentityProviderRepresentation) {
                Response response
                        = keycloakClient.realm(realmName).identityProviders().create((IdentityProviderRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException(
                    "Create identity provider requires POJO request with IdentityProviderRepresentation");
        }
    }

    private void updateResourcePermission(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String permissionId = exchange.getIn().getHeader(KeycloakConstants.PERMISSION_ID, String.class);
        if (ObjectHelper.isEmpty(permissionId)) {
            throw new IllegalArgumentException("Permission ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                 
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies().policy(permissionId)
                        .update((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Permission updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update permission requires POJO request with PolicyRepresentation");
        }
    }

    private void createIdentityProvider(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof IdentityProviderRepresentation) {
                Response response
                        = keycloakClient.realm(realmName).identityProviders().create((IdentityProviderRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException(
                    "Create identity provider requires POJO request with IdentityProviderRepresentation");
        }
    }

    private void updateClientRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
        if (ObjectHelper.isEmpty(roleName)) {
            throw new IllegalArgumentException(MISSING_ROLE_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).roles().get(roleName)
                        .update((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client role updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client role requires POJO request with RoleRepresentation");
        }
    }

    private void createIdentityProvider(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof IdentityProviderRepresentation) {
                Response response
                        = keycloakClient.realm(realmName).identityProviders().create((IdentityProviderRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException(
                    "Create identity provider requires POJO request with IdentityProviderRepresentation");
        }
    }

    private void updateResource(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String resourceId = exchange.getIn().getHeader(KeycloakConstants.RESOURCE_ID, String.class);
        if (ObjectHelper.isEmpty(resourceId)) {
            throw new IllegalArgumentException("Resource ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourceRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().resources().resource(resourceId)
                        .update((ResourceRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Resource updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update resource requires POJO request with ResourceRepresentation");
        }
    }

    private void createIdentityProvider(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof IdentityProviderRepresentation) {
                Response response
                        = keycloakClient.realm(realmName).identityProviders().create((IdentityProviderRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException(
                    "Create identity provider requires POJO request with IdentityProviderRepresentation");
        }
    }

    private void updateResourcePolicy(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String policyId = exchange.getIn().getHeader(KeycloakConstants.POLICY_ID, String.class);
        if (ObjectHelper.isEmpty(policyId)) {
            throw new IllegalArgumentException("Policy ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies().policy(policyId)
                        .update((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Policy updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update policy requires POJO request with PolicyRepresentation");
        }
    }

    private void updateRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
        if (ObjectHelper.isEmpty(roleName)) {
            throw new IllegalArgumentException(MISSING_ROLE_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).roles().get(roleName).update((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Role updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update role requires POJO request with RoleRepresentation");
        }
    }

    private void updateClientScope(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientScopeId = exchange.getIn().getHeader(KeycloakConstants.CLIENT_SCOPE_ID, String.class);
        if (ObjectHelper.isEmpty(clientScopeId)) {
            throw new IllegalArgumentException("Client scope ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientScopeRepresentation) {
                keycloakClient.realm(realmName).clientScopes().get(clientScopeId).update((ClientScopeRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client scope updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client scope requires POJO request with ClientScopeRepresentation");
        }
    }

    private void updateRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
        if (ObjectHelper.isEmpty(roleName)) {
            throw new IllegalArgumentException(MISSING_ROLE_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).roles().get(roleName).update((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Role updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update role requires POJO request with RoleRepresentation");
        }
    }

    private void updateUser(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String userId = exchange.getIn().getHeader(KeycloakConstants.USER_ID, String.class);
        if (ObjectHelper.isEmpty(userId)) {
            throw new IllegalArgumentException(MISSING_USER_ID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof UserRepresentation) {
                keycloakClient.realm(realmName).users().get(userId).update((UserRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("User updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update user requires POJO request with UserRepresentation");
        }
    }

    private void updateRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
        if (ObjectHelper.isEmpty(roleName)) {
            throw new IllegalArgumentException(MISSING_ROLE_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).roles().get(roleName).update((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Role updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update role requires POJO request with RoleRepresentation");
        }
    }

    private void createResource(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourceRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().resources()
                        .create((ResourceRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create resource requires POJO request with ResourceRepresentation");
        }
    }

    private void updateRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
        if (ObjectHelper.isEmpty(roleName)) {
            throw new IllegalArgumentException(MISSING_ROLE_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).roles().get(roleName).update((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Role updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update role requires POJO request with RoleRepresentation");
        }
    }

    private void createResourcePolicy(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies()
                        .create((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create policy requires POJO request with PolicyRepresentation");
        }
    }

    private void updateRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
        if (ObjectHelper.isEmpty(roleName)) {
            throw new IllegalArgumentException(MISSING_ROLE_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).roles().get(roleName).update((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Role updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update role requires POJO request with RoleRepresentation");
        }
    }

    private void createResourcePermission(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourcePermissionRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().permissions()
                        .resource().create((ResourcePermissionRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create permission requires POJO request with ResourcePermissionRepresentation");
        }
    }

    private void updateRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
        if (ObjectHelper.isEmpty(roleName)) {
            throw new IllegalArgumentException(MISSING_ROLE_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).roles().get(roleName).update((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Role updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update role requires POJO request with RoleRepresentation");
        }
    }

    private void updateResourcePermission(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String permissionId = exchange.getIn().getHeader(KeycloakConstants.PERMISSION_ID, String.class);
        if (ObjectHelper.isEmpty(permissionId)) {
            throw new IllegalArgumentException("Permission ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                 
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies().policy(permissionId)
                        .update((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Permission updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update permission requires POJO request with PolicyRepresentation");
        }
    }

    private void updateRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
        if (ObjectHelper.isEmpty(roleName)) {
            throw new IllegalArgumentException(MISSING_ROLE_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).roles().get(roleName).update((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Role updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update role requires POJO request with RoleRepresentation");
        }
    }

    private void updateClientRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
        if (ObjectHelper.isEmpty(roleName)) {
            throw new IllegalArgumentException(MISSING_ROLE_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).roles().get(roleName)
                        .update((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client role updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client role requires POJO request with RoleRepresentation");
        }
    }

    private void updateRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
        if (ObjectHelper.isEmpty(roleName)) {
            throw new IllegalArgumentException(MISSING_ROLE_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).roles().get(roleName).update((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Role updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update role requires POJO request with RoleRepresentation");
        }
    }

    private void updateResource(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String resourceId = exchange.getIn().getHeader(KeycloakConstants.RESOURCE_ID, String.class);
        if (ObjectHelper.isEmpty(resourceId)) {
            throw new IllegalArgumentException("Resource ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourceRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().resources().resource(resourceId)
                        .update((ResourceRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Resource updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update resource requires POJO request with ResourceRepresentation");
        }
    }

    private void updateRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
        if (ObjectHelper.isEmpty(roleName)) {
            throw new IllegalArgumentException(MISSING_ROLE_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).roles().get(roleName).update((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Role updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update role requires POJO request with RoleRepresentation");
        }
    }

    private void updateResourcePolicy(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String policyId = exchange.getIn().getHeader(KeycloakConstants.POLICY_ID, String.class);
        if (ObjectHelper.isEmpty(policyId)) {
            throw new IllegalArgumentException("Policy ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies().policy(policyId)
                        .update((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Policy updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update policy requires POJO request with PolicyRepresentation");
        }
    }

    private void updateClientScope(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientScopeId = exchange.getIn().getHeader(KeycloakConstants.CLIENT_SCOPE_ID, String.class);
        if (ObjectHelper.isEmpty(clientScopeId)) {
            throw new IllegalArgumentException("Client scope ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientScopeRepresentation) {
                keycloakClient.realm(realmName).clientScopes().get(clientScopeId).update((ClientScopeRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client scope updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client scope requires POJO request with ClientScopeRepresentation");
        }
    }

    private void updateUser(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String userId = exchange.getIn().getHeader(KeycloakConstants.USER_ID, String.class);
        if (ObjectHelper.isEmpty(userId)) {
            throw new IllegalArgumentException(MISSING_USER_ID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof UserRepresentation) {
                keycloakClient.realm(realmName).users().get(userId).update((UserRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("User updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update user requires POJO request with UserRepresentation");
        }
    }

    private void updateClientScope(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientScopeId = exchange.getIn().getHeader(KeycloakConstants.CLIENT_SCOPE_ID, String.class);
        if (ObjectHelper.isEmpty(clientScopeId)) {
            throw new IllegalArgumentException("Client scope ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientScopeRepresentation) {
                keycloakClient.realm(realmName).clientScopes().get(clientScopeId).update((ClientScopeRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client scope updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client scope requires POJO request with ClientScopeRepresentation");
        }
    }

    private void createResource(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourceRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().resources()
                        .create((ResourceRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create resource requires POJO request with ResourceRepresentation");
        }
    }

    private void updateClientScope(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientScopeId = exchange.getIn().getHeader(KeycloakConstants.CLIENT_SCOPE_ID, String.class);
        if (ObjectHelper.isEmpty(clientScopeId)) {
            throw new IllegalArgumentException("Client scope ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientScopeRepresentation) {
                keycloakClient.realm(realmName).clientScopes().get(clientScopeId).update((ClientScopeRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client scope updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client scope requires POJO request with ClientScopeRepresentation");
        }
    }

    private void createResourcePolicy(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies()
                        .create((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create policy requires POJO request with PolicyRepresentation");
        }
    }

    private void updateClientScope(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientScopeId = exchange.getIn().getHeader(KeycloakConstants.CLIENT_SCOPE_ID, String.class);
        if (ObjectHelper.isEmpty(clientScopeId)) {
            throw new IllegalArgumentException("Client scope ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientScopeRepresentation) {
                keycloakClient.realm(realmName).clientScopes().get(clientScopeId).update((ClientScopeRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client scope updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client scope requires POJO request with ClientScopeRepresentation");
        }
    }

    private void createResourcePermission(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourcePermissionRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().permissions()
                        .resource().create((ResourcePermissionRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create permission requires POJO request with ResourcePermissionRepresentation");
        }
    }

    private void updateClientScope(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientScopeId = exchange.getIn().getHeader(KeycloakConstants.CLIENT_SCOPE_ID, String.class);
        if (ObjectHelper.isEmpty(clientScopeId)) {
            throw new IllegalArgumentException("Client scope ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientScopeRepresentation) {
                keycloakClient.realm(realmName).clientScopes().get(clientScopeId).update((ClientScopeRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client scope updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client scope requires POJO request with ClientScopeRepresentation");
        }
    }

    private void updateResourcePermission(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String permissionId = exchange.getIn().getHeader(KeycloakConstants.PERMISSION_ID, String.class);
        if (ObjectHelper.isEmpty(permissionId)) {
            throw new IllegalArgumentException("Permission ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                 
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies().policy(permissionId)
                        .update((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Permission updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update permission requires POJO request with PolicyRepresentation");
        }
    }

    private void updateClientScope(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientScopeId = exchange.getIn().getHeader(KeycloakConstants.CLIENT_SCOPE_ID, String.class);
        if (ObjectHelper.isEmpty(clientScopeId)) {
            throw new IllegalArgumentException("Client scope ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientScopeRepresentation) {
                keycloakClient.realm(realmName).clientScopes().get(clientScopeId).update((ClientScopeRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client scope updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client scope requires POJO request with ClientScopeRepresentation");
        }
    }

    private void updateClientRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
        if (ObjectHelper.isEmpty(roleName)) {
            throw new IllegalArgumentException(MISSING_ROLE_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).roles().get(roleName)
                        .update((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client role updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client role requires POJO request with RoleRepresentation");
        }
    }

    private void updateClientScope(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientScopeId = exchange.getIn().getHeader(KeycloakConstants.CLIENT_SCOPE_ID, String.class);
        if (ObjectHelper.isEmpty(clientScopeId)) {
            throw new IllegalArgumentException("Client scope ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientScopeRepresentation) {
                keycloakClient.realm(realmName).clientScopes().get(clientScopeId).update((ClientScopeRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client scope updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client scope requires POJO request with ClientScopeRepresentation");
        }
    }

    private void updateResource(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String resourceId = exchange.getIn().getHeader(KeycloakConstants.RESOURCE_ID, String.class);
        if (ObjectHelper.isEmpty(resourceId)) {
            throw new IllegalArgumentException("Resource ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourceRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().resources().resource(resourceId)
                        .update((ResourceRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Resource updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update resource requires POJO request with ResourceRepresentation");
        }
    }

    private void updateClientScope(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientScopeId = exchange.getIn().getHeader(KeycloakConstants.CLIENT_SCOPE_ID, String.class);
        if (ObjectHelper.isEmpty(clientScopeId)) {
            throw new IllegalArgumentException("Client scope ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientScopeRepresentation) {
                keycloakClient.realm(realmName).clientScopes().get(clientScopeId).update((ClientScopeRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client scope updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client scope requires POJO request with ClientScopeRepresentation");
        }
    }

    private void updateResourcePolicy(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String policyId = exchange.getIn().getHeader(KeycloakConstants.POLICY_ID, String.class);
        if (ObjectHelper.isEmpty(policyId)) {
            throw new IllegalArgumentException("Policy ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies().policy(policyId)
                        .update((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Policy updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update policy requires POJO request with PolicyRepresentation");
        }
    }

    private void updateUser(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String userId = exchange.getIn().getHeader(KeycloakConstants.USER_ID, String.class);
        if (ObjectHelper.isEmpty(userId)) {
            throw new IllegalArgumentException(MISSING_USER_ID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof UserRepresentation) {
                keycloakClient.realm(realmName).users().get(userId).update((UserRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("User updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update user requires POJO request with UserRepresentation");
        }
    }

    private void createResource(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourceRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().resources()
                        .create((ResourceRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create resource requires POJO request with ResourceRepresentation");
        }
    }

    private void updateUser(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String userId = exchange.getIn().getHeader(KeycloakConstants.USER_ID, String.class);
        if (ObjectHelper.isEmpty(userId)) {
            throw new IllegalArgumentException(MISSING_USER_ID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof UserRepresentation) {
                keycloakClient.realm(realmName).users().get(userId).update((UserRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("User updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update user requires POJO request with UserRepresentation");
        }
    }

    private void createResourcePolicy(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies()
                        .create((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create policy requires POJO request with PolicyRepresentation");
        }
    }

    private void updateUser(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String userId = exchange.getIn().getHeader(KeycloakConstants.USER_ID, String.class);
        if (ObjectHelper.isEmpty(userId)) {
            throw new IllegalArgumentException(MISSING_USER_ID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof UserRepresentation) {
                keycloakClient.realm(realmName).users().get(userId).update((UserRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("User updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update user requires POJO request with UserRepresentation");
        }
    }

    private void createResourcePermission(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourcePermissionRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().permissions()
                        .resource().create((ResourcePermissionRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create permission requires POJO request with ResourcePermissionRepresentation");
        }
    }

    private void updateUser(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String userId = exchange.getIn().getHeader(KeycloakConstants.USER_ID, String.class);
        if (ObjectHelper.isEmpty(userId)) {
            throw new IllegalArgumentException(MISSING_USER_ID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof UserRepresentation) {
                keycloakClient.realm(realmName).users().get(userId).update((UserRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("User updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update user requires POJO request with UserRepresentation");
        }
    }

    private void updateResourcePermission(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String permissionId = exchange.getIn().getHeader(KeycloakConstants.PERMISSION_ID, String.class);
        if (ObjectHelper.isEmpty(permissionId)) {
            throw new IllegalArgumentException("Permission ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                 
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies().policy(permissionId)
                        .update((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Permission updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update permission requires POJO request with PolicyRepresentation");
        }
    }

    private void updateUser(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String userId = exchange.getIn().getHeader(KeycloakConstants.USER_ID, String.class);
        if (ObjectHelper.isEmpty(userId)) {
            throw new IllegalArgumentException(MISSING_USER_ID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof UserRepresentation) {
                keycloakClient.realm(realmName).users().get(userId).update((UserRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("User updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update user requires POJO request with UserRepresentation");
        }
    }

    private void updateClientRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
        if (ObjectHelper.isEmpty(roleName)) {
            throw new IllegalArgumentException(MISSING_ROLE_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).roles().get(roleName)
                        .update((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client role updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client role requires POJO request with RoleRepresentation");
        }
    }

    private void updateUser(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String userId = exchange.getIn().getHeader(KeycloakConstants.USER_ID, String.class);
        if (ObjectHelper.isEmpty(userId)) {
            throw new IllegalArgumentException(MISSING_USER_ID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof UserRepresentation) {
                keycloakClient.realm(realmName).users().get(userId).update((UserRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("User updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update user requires POJO request with UserRepresentation");
        }
    }

    private void updateResource(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String resourceId = exchange.getIn().getHeader(KeycloakConstants.RESOURCE_ID, String.class);
        if (ObjectHelper.isEmpty(resourceId)) {
            throw new IllegalArgumentException("Resource ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourceRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().resources().resource(resourceId)
                        .update((ResourceRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Resource updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update resource requires POJO request with ResourceRepresentation");
        }
    }

    private void updateUser(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String userId = exchange.getIn().getHeader(KeycloakConstants.USER_ID, String.class);
        if (ObjectHelper.isEmpty(userId)) {
            throw new IllegalArgumentException(MISSING_USER_ID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof UserRepresentation) {
                keycloakClient.realm(realmName).users().get(userId).update((UserRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("User updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update user requires POJO request with UserRepresentation");
        }
    }

    private void updateResourcePolicy(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String policyId = exchange.getIn().getHeader(KeycloakConstants.POLICY_ID, String.class);
        if (ObjectHelper.isEmpty(policyId)) {
            throw new IllegalArgumentException("Policy ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies().policy(policyId)
                        .update((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Policy updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update policy requires POJO request with PolicyRepresentation");
        }
    }

    private void createResource(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourceRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().resources()
                        .create((ResourceRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create resource requires POJO request with ResourceRepresentation");
        }
    }

    private void createResourcePolicy(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies()
                        .create((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create policy requires POJO request with PolicyRepresentation");
        }
    }

    private void createResource(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourceRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().resources()
                        .create((ResourceRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create resource requires POJO request with ResourceRepresentation");
        }
    }

    private void createResourcePermission(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourcePermissionRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().permissions()
                        .resource().create((ResourcePermissionRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create permission requires POJO request with ResourcePermissionRepresentation");
        }
    }

    private void createResource(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourceRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().resources()
                        .create((ResourceRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create resource requires POJO request with ResourceRepresentation");
        }
    }

    private void updateResourcePermission(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String permissionId = exchange.getIn().getHeader(KeycloakConstants.PERMISSION_ID, String.class);
        if (ObjectHelper.isEmpty(permissionId)) {
            throw new IllegalArgumentException("Permission ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                 
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies().policy(permissionId)
                        .update((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Permission updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update permission requires POJO request with PolicyRepresentation");
        }
    }

    private void createResource(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourceRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().resources()
                        .create((ResourceRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create resource requires POJO request with ResourceRepresentation");
        }
    }

    private void updateClientRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
        if (ObjectHelper.isEmpty(roleName)) {
            throw new IllegalArgumentException(MISSING_ROLE_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).roles().get(roleName)
                        .update((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client role updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client role requires POJO request with RoleRepresentation");
        }
    }

    private void createResource(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourceRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().resources()
                        .create((ResourceRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create resource requires POJO request with ResourceRepresentation");
        }
    }

    private void updateResource(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String resourceId = exchange.getIn().getHeader(KeycloakConstants.RESOURCE_ID, String.class);
        if (ObjectHelper.isEmpty(resourceId)) {
            throw new IllegalArgumentException("Resource ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourceRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().resources().resource(resourceId)
                        .update((ResourceRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Resource updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update resource requires POJO request with ResourceRepresentation");
        }
    }

    private void createResource(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourceRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().resources()
                        .create((ResourceRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create resource requires POJO request with ResourceRepresentation");
        }
    }

    private void updateResourcePolicy(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String policyId = exchange.getIn().getHeader(KeycloakConstants.POLICY_ID, String.class);
        if (ObjectHelper.isEmpty(policyId)) {
            throw new IllegalArgumentException("Policy ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies().policy(policyId)
                        .update((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Policy updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update policy requires POJO request with PolicyRepresentation");
        }
    }

    private void createResourcePolicy(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies()
                        .create((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create policy requires POJO request with PolicyRepresentation");
        }
    }

    private void createResourcePermission(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourcePermissionRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().permissions()
                        .resource().create((ResourcePermissionRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create permission requires POJO request with ResourcePermissionRepresentation");
        }
    }

    private void createResourcePolicy(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies()
                        .create((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create policy requires POJO request with PolicyRepresentation");
        }
    }

    private void updateResourcePermission(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String permissionId = exchange.getIn().getHeader(KeycloakConstants.PERMISSION_ID, String.class);
        if (ObjectHelper.isEmpty(permissionId)) {
            throw new IllegalArgumentException("Permission ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                 
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies().policy(permissionId)
                        .update((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Permission updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update permission requires POJO request with PolicyRepresentation");
        }
    }

    private void createResourcePolicy(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies()
                        .create((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create policy requires POJO request with PolicyRepresentation");
        }
    }

    private void updateClientRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
        if (ObjectHelper.isEmpty(roleName)) {
            throw new IllegalArgumentException(MISSING_ROLE_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).roles().get(roleName)
                        .update((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client role updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client role requires POJO request with RoleRepresentation");
        }
    }

    private void createResourcePolicy(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies()
                        .create((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create policy requires POJO request with PolicyRepresentation");
        }
    }

    private void updateResource(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String resourceId = exchange.getIn().getHeader(KeycloakConstants.RESOURCE_ID, String.class);
        if (ObjectHelper.isEmpty(resourceId)) {
            throw new IllegalArgumentException("Resource ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourceRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().resources().resource(resourceId)
                        .update((ResourceRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Resource updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update resource requires POJO request with ResourceRepresentation");
        }
    }

    private void createResourcePolicy(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies()
                        .create((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create policy requires POJO request with PolicyRepresentation");
        }
    }

    private void updateResourcePolicy(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String policyId = exchange.getIn().getHeader(KeycloakConstants.POLICY_ID, String.class);
        if (ObjectHelper.isEmpty(policyId)) {
            throw new IllegalArgumentException("Policy ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies().policy(policyId)
                        .update((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Policy updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update policy requires POJO request with PolicyRepresentation");
        }
    }

    private void createResourcePermission(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourcePermissionRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().permissions()
                        .resource().create((ResourcePermissionRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create permission requires POJO request with ResourcePermissionRepresentation");
        }
    }

    private void updateResourcePermission(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String permissionId = exchange.getIn().getHeader(KeycloakConstants.PERMISSION_ID, String.class);
        if (ObjectHelper.isEmpty(permissionId)) {
            throw new IllegalArgumentException("Permission ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                 
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies().policy(permissionId)
                        .update((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Permission updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update permission requires POJO request with PolicyRepresentation");
        }
    }

    private void createResourcePermission(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourcePermissionRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().permissions()
                        .resource().create((ResourcePermissionRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create permission requires POJO request with ResourcePermissionRepresentation");
        }
    }

    private void updateClientRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
        if (ObjectHelper.isEmpty(roleName)) {
            throw new IllegalArgumentException(MISSING_ROLE_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).roles().get(roleName)
                        .update((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client role updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client role requires POJO request with RoleRepresentation");
        }
    }

    private void createResourcePermission(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourcePermissionRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().permissions()
                        .resource().create((ResourcePermissionRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create permission requires POJO request with ResourcePermissionRepresentation");
        }
    }

    private void updateResource(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String resourceId = exchange.getIn().getHeader(KeycloakConstants.RESOURCE_ID, String.class);
        if (ObjectHelper.isEmpty(resourceId)) {
            throw new IllegalArgumentException("Resource ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourceRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().resources().resource(resourceId)
                        .update((ResourceRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Resource updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update resource requires POJO request with ResourceRepresentation");
        }
    }

    private void createResourcePermission(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourcePermissionRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().permissions()
                        .resource().create((ResourcePermissionRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create permission requires POJO request with ResourcePermissionRepresentation");
        }
    }

    private void updateResourcePolicy(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String policyId = exchange.getIn().getHeader(KeycloakConstants.POLICY_ID, String.class);
        if (ObjectHelper.isEmpty(policyId)) {
            throw new IllegalArgumentException("Policy ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies().policy(policyId)
                        .update((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Policy updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update policy requires POJO request with PolicyRepresentation");
        }
    }

    private void updateResourcePermission(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String permissionId = exchange.getIn().getHeader(KeycloakConstants.PERMISSION_ID, String.class);
        if (ObjectHelper.isEmpty(permissionId)) {
            throw new IllegalArgumentException("Permission ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                 
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies().policy(permissionId)
                        .update((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Permission updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update permission requires POJO request with PolicyRepresentation");
        }
    }

    private void updateClientRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
        if (ObjectHelper.isEmpty(roleName)) {
            throw new IllegalArgumentException(MISSING_ROLE_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).roles().get(roleName)
                        .update((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client role updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client role requires POJO request with RoleRepresentation");
        }
    }

    private void updateResourcePermission(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String permissionId = exchange.getIn().getHeader(KeycloakConstants.PERMISSION_ID, String.class);
        if (ObjectHelper.isEmpty(permissionId)) {
            throw new IllegalArgumentException("Permission ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                 
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies().policy(permissionId)
                        .update((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Permission updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update permission requires POJO request with PolicyRepresentation");
        }
    }

    private void updateResource(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String resourceId = exchange.getIn().getHeader(KeycloakConstants.RESOURCE_ID, String.class);
        if (ObjectHelper.isEmpty(resourceId)) {
            throw new IllegalArgumentException("Resource ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourceRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().resources().resource(resourceId)
                        .update((ResourceRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Resource updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update resource requires POJO request with ResourceRepresentation");
        }
    }

    private void updateResourcePermission(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String permissionId = exchange.getIn().getHeader(KeycloakConstants.PERMISSION_ID, String.class);
        if (ObjectHelper.isEmpty(permissionId)) {
            throw new IllegalArgumentException("Permission ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                 
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies().policy(permissionId)
                        .update((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Permission updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update permission requires POJO request with PolicyRepresentation");
        }
    }

    private void updateResourcePolicy(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String policyId = exchange.getIn().getHeader(KeycloakConstants.POLICY_ID, String.class);
        if (ObjectHelper.isEmpty(policyId)) {
            throw new IllegalArgumentException("Policy ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies().policy(policyId)
                        .update((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Policy updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update policy requires POJO request with PolicyRepresentation");
        }
    }

    private void updateClientRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
        if (ObjectHelper.isEmpty(roleName)) {
            throw new IllegalArgumentException(MISSING_ROLE_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).roles().get(roleName)
                        .update((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client role updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client role requires POJO request with RoleRepresentation");
        }
    }

    private void updateResource(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String resourceId = exchange.getIn().getHeader(KeycloakConstants.RESOURCE_ID, String.class);
        if (ObjectHelper.isEmpty(resourceId)) {
            throw new IllegalArgumentException("Resource ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourceRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().resources().resource(resourceId)
                        .update((ResourceRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Resource updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update resource requires POJO request with ResourceRepresentation");
        }
    }

    private void updateClientRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
        if (ObjectHelper.isEmpty(roleName)) {
            throw new IllegalArgumentException(MISSING_ROLE_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).roles().get(roleName)
                        .update((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client role updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client role requires POJO request with RoleRepresentation");
        }
    }

    private void updateResourcePolicy(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String policyId = exchange.getIn().getHeader(KeycloakConstants.POLICY_ID, String.class);
        if (ObjectHelper.isEmpty(policyId)) {
            throw new IllegalArgumentException("Policy ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies().policy(policyId)
                        .update((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Policy updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update policy requires POJO request with PolicyRepresentation");
        }
    }

    private void updateResource(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String resourceId = exchange.getIn().getHeader(KeycloakConstants.RESOURCE_ID, String.class);
        if (ObjectHelper.isEmpty(resourceId)) {
            throw new IllegalArgumentException("Resource ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourceRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().resources().resource(resourceId)
                        .update((ResourceRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Resource updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update resource requires POJO request with ResourceRepresentation");
        }
    }

    private void updateResourcePolicy(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String policyId = exchange.getIn().getHeader(KeycloakConstants.POLICY_ID, String.class);
        if (ObjectHelper.isEmpty(policyId)) {
            throw new IllegalArgumentException("Policy ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies().policy(policyId)
                        .update((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Policy updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update policy requires POJO request with PolicyRepresentation");
        }
    }

    private void createUser(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof UserRepresentation) {
                Response response = keycloakClient.realm(realmName).users().create((UserRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            UserRepresentation user = new UserRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.USERNAME))) {
                String username = exchange.getIn().getHeader(KeycloakConstants.USERNAME, String.class);
                user.setUsername(username);
                user.setEnabled(true);

                if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.USER_EMAIL))) {
                    user.setEmail(exchange.getIn().getHeader(KeycloakConstants.USER_EMAIL, String.class));
                }
                if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.USER_FIRST_NAME))) {
                    user.setFirstName(exchange.getIn().getHeader(KeycloakConstants.USER_FIRST_NAME, String.class));
                }
                if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.USER_LAST_NAME))) {
                    user.setLastName(exchange.getIn().getHeader(KeycloakConstants.USER_LAST_NAME, String.class));
                }
            } else {
                throw new IllegalArgumentException(MISSING_USER_NAME);
            }
            Response response = keycloakClient.realm(realmName).users().create(user);
            Message message = getMessageForResponse(exchange);
            message.setBody(response);
        }
    }

    private void createClient(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().create((ClientRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            ClientRepresentation client = new ClientRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.CLIENT_ID))) {
                String clientId = exchange.getIn().getHeader(KeycloakConstants.CLIENT_ID, String.class);
                client.setClientId(clientId);
                client.setEnabled(true);
            } else {
                throw new IllegalArgumentException(MISSING_CLIENT_ID);
            }
            Response response = keycloakClient.realm(realmName).clients().create(client);
            Message message = getMessageForResponse(exchange);
            message.setBody(response);
        }
    }

    private void createUser(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof UserRepresentation) {
                Response response = keycloakClient.realm(realmName).users().create((UserRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            UserRepresentation user = new UserRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.USERNAME))) {
                String username = exchange.getIn().getHeader(KeycloakConstants.USERNAME, String.class);
                user.setUsername(username);
                user.setEnabled(true);

                if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.USER_EMAIL))) {
                    user.setEmail(exchange.getIn().getHeader(KeycloakConstants.USER_EMAIL, String.class));
                }
                if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.USER_FIRST_NAME))) {
                    user.setFirstName(exchange.getIn().getHeader(KeycloakConstants.USER_FIRST_NAME, String.class));
                }
                if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.USER_LAST_NAME))) {
                    user.setLastName(exchange.getIn().getHeader(KeycloakConstants.USER_LAST_NAME, String.class));
                }
            } else {
                throw new IllegalArgumentException(MISSING_USER_NAME);
            }
            Response response = keycloakClient.realm(realmName).users().create(user);
            Message message = getMessageForResponse(exchange);
            message.setBody(response);
        }
    }

    private void createClientScope(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientScopeRepresentation) {
                Response response = keycloakClient.realm(realmName).clientScopes().create((ClientScopeRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            ClientScopeRepresentation clientScope = new ClientScopeRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.CLIENT_SCOPE_NAME))) {
                String scopeName = exchange.getIn().getHeader(KeycloakConstants.CLIENT_SCOPE_NAME, String.class);
                clientScope.setName(scopeName);
            } else {
                throw new IllegalArgumentException("Client scope name must be specified");
            }
            Response response = keycloakClient.realm(realmName).clientScopes().create(clientScope);
            Message message = getMessageForResponse(exchange);
            message.setBody(response);
        }
    }

    private void createUser(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof UserRepresentation) {
                Response response = keycloakClient.realm(realmName).users().create((UserRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            UserRepresentation user = new UserRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.USERNAME))) {
                String username = exchange.getIn().getHeader(KeycloakConstants.USERNAME, String.class);
                user.setUsername(username);
                user.setEnabled(true);

                if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.USER_EMAIL))) {
                    user.setEmail(exchange.getIn().getHeader(KeycloakConstants.USER_EMAIL, String.class));
                }
                if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.USER_FIRST_NAME))) {
                    user.setFirstName(exchange.getIn().getHeader(KeycloakConstants.USER_FIRST_NAME, String.class));
                }
                if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.USER_LAST_NAME))) {
                    user.setLastName(exchange.getIn().getHeader(KeycloakConstants.USER_LAST_NAME, String.class));
                }
            } else {
                throw new IllegalArgumentException(MISSING_USER_NAME);
            }
            Response response = keycloakClient.realm(realmName).users().create(user);
            Message message = getMessageForResponse(exchange);
            message.setBody(response);
        }
    }

    private void createGroup(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof GroupRepresentation) {
                Response response = keycloakClient.realm(realmName).groups().add((GroupRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            GroupRepresentation group = new GroupRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.GROUP_NAME))) {
                String groupName = exchange.getIn().getHeader(KeycloakConstants.GROUP_NAME, String.class);
                group.setName(groupName);
            } else {
                throw new IllegalArgumentException(MISSING_GROUP_NAME);
            }
            Response response = keycloakClient.realm(realmName).groups().add(group);
            Message message = getMessageForResponse(exchange);
            message.setBody(response);
        }
    }

    private void createUser(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof UserRepresentation) {
                Response response = keycloakClient.realm(realmName).users().create((UserRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            UserRepresentation user = new UserRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.USERNAME))) {
                String username = exchange.getIn().getHeader(KeycloakConstants.USERNAME, String.class);
                user.setUsername(username);
                user.setEnabled(true);

                if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.USER_EMAIL))) {
                    user.setEmail(exchange.getIn().getHeader(KeycloakConstants.USER_EMAIL, String.class));
                }
                if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.USER_FIRST_NAME))) {
                    user.setFirstName(exchange.getIn().getHeader(KeycloakConstants.USER_FIRST_NAME, String.class));
                }
                if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.USER_LAST_NAME))) {
                    user.setLastName(exchange.getIn().getHeader(KeycloakConstants.USER_LAST_NAME, String.class));
                }
            } else {
                throw new IllegalArgumentException(MISSING_USER_NAME);
            }
            Response response = keycloakClient.realm(realmName).users().create(user);
            Message message = getMessageForResponse(exchange);
            message.setBody(response);
        }
    }

    private void createRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).roles().create((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Role created successfully");
            }
        } else {
            RoleRepresentation role = new RoleRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME))) {
                String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
                role.setName(roleName);

                if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.ROLE_DESCRIPTION))) {
                    role.setDescription(exchange.getIn().getHeader(KeycloakConstants.ROLE_DESCRIPTION, String.class));
                }
            } else {
                throw new IllegalArgumentException(MISSING_ROLE_NAME);
            }
            keycloakClient.realm(realmName).roles().create(role);
            Message message = getMessageForResponse(exchange);
            message.setBody("Role created successfully");
        }
    }

    private void createUser(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof UserRepresentation) {
                Response response = keycloakClient.realm(realmName).users().create((UserRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            UserRepresentation user = new UserRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.USERNAME))) {
                String username = exchange.getIn().getHeader(KeycloakConstants.USERNAME, String.class);
                user.setUsername(username);
                user.setEnabled(true);

                if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.USER_EMAIL))) {
                    user.setEmail(exchange.getIn().getHeader(KeycloakConstants.USER_EMAIL, String.class));
                }
                if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.USER_FIRST_NAME))) {
                    user.setFirstName(exchange.getIn().getHeader(KeycloakConstants.USER_FIRST_NAME, String.class));
                }
                if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.USER_LAST_NAME))) {
                    user.setLastName(exchange.getIn().getHeader(KeycloakConstants.USER_LAST_NAME, String.class));
                }
            } else {
                throw new IllegalArgumentException(MISSING_USER_NAME);
            }
            Response response = keycloakClient.realm(realmName).users().create(user);
            Message message = getMessageForResponse(exchange);
            message.setBody(response);
        }
    }

    private void createClientRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).roles().create((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client role created successfully");
            }
        } else {
            RoleRepresentation role = new RoleRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME))) {
                String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
                role.setName(roleName);

                if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.ROLE_DESCRIPTION))) {
                    role.setDescription(exchange.getIn().getHeader(KeycloakConstants.ROLE_DESCRIPTION, String.class));
                }
            } else {
                throw new IllegalArgumentException(MISSING_ROLE_NAME);
            }
            keycloakClient.realm(realmName).clients().get(clientUuid).roles().create(role);
            Message message = getMessageForResponse(exchange);
            message.setBody("Client role created successfully");
        }
    }

    private void createClient(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().create((ClientRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            ClientRepresentation client = new ClientRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.CLIENT_ID))) {
                String clientId = exchange.getIn().getHeader(KeycloakConstants.CLIENT_ID, String.class);
                client.setClientId(clientId);
                client.setEnabled(true);
            } else {
                throw new IllegalArgumentException(MISSING_CLIENT_ID);
            }
            Response response = keycloakClient.realm(realmName).clients().create(client);
            Message message = getMessageForResponse(exchange);
            message.setBody(response);
        }
    }

    private void createClientScope(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientScopeRepresentation) {
                Response response = keycloakClient.realm(realmName).clientScopes().create((ClientScopeRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            ClientScopeRepresentation clientScope = new ClientScopeRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.CLIENT_SCOPE_NAME))) {
                String scopeName = exchange.getIn().getHeader(KeycloakConstants.CLIENT_SCOPE_NAME, String.class);
                clientScope.setName(scopeName);
            } else {
                throw new IllegalArgumentException("Client scope name must be specified");
            }
            Response response = keycloakClient.realm(realmName).clientScopes().create(clientScope);
            Message message = getMessageForResponse(exchange);
            message.setBody(response);
        }
    }

    private void createClient(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().create((ClientRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            ClientRepresentation client = new ClientRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.CLIENT_ID))) {
                String clientId = exchange.getIn().getHeader(KeycloakConstants.CLIENT_ID, String.class);
                client.setClientId(clientId);
                client.setEnabled(true);
            } else {
                throw new IllegalArgumentException(MISSING_CLIENT_ID);
            }
            Response response = keycloakClient.realm(realmName).clients().create(client);
            Message message = getMessageForResponse(exchange);
            message.setBody(response);
        }
    }

    private void createGroup(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof GroupRepresentation) {
                Response response = keycloakClient.realm(realmName).groups().add((GroupRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            GroupRepresentation group = new GroupRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.GROUP_NAME))) {
                String groupName = exchange.getIn().getHeader(KeycloakConstants.GROUP_NAME, String.class);
                group.setName(groupName);
            } else {
                throw new IllegalArgumentException(MISSING_GROUP_NAME);
            }
            Response response = keycloakClient.realm(realmName).groups().add(group);
            Message message = getMessageForResponse(exchange);
            message.setBody(response);
        }
    }

    private void createClient(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().create((ClientRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            ClientRepresentation client = new ClientRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.CLIENT_ID))) {
                String clientId = exchange.getIn().getHeader(KeycloakConstants.CLIENT_ID, String.class);
                client.setClientId(clientId);
                client.setEnabled(true);
            } else {
                throw new IllegalArgumentException(MISSING_CLIENT_ID);
            }
            Response response = keycloakClient.realm(realmName).clients().create(client);
            Message message = getMessageForResponse(exchange);
            message.setBody(response);
        }
    }

    private void createRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).roles().create((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Role created successfully");
            }
        } else {
            RoleRepresentation role = new RoleRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME))) {
                String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
                role.setName(roleName);

                if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.ROLE_DESCRIPTION))) {
                    role.setDescription(exchange.getIn().getHeader(KeycloakConstants.ROLE_DESCRIPTION, String.class));
                }
            } else {
                throw new IllegalArgumentException(MISSING_ROLE_NAME);
            }
            keycloakClient.realm(realmName).roles().create(role);
            Message message = getMessageForResponse(exchange);
            message.setBody("Role created successfully");
        }
    }

    private void createClient(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().create((ClientRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            ClientRepresentation client = new ClientRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.CLIENT_ID))) {
                String clientId = exchange.getIn().getHeader(KeycloakConstants.CLIENT_ID, String.class);
                client.setClientId(clientId);
                client.setEnabled(true);
            } else {
                throw new IllegalArgumentException(MISSING_CLIENT_ID);
            }
            Response response = keycloakClient.realm(realmName).clients().create(client);
            Message message = getMessageForResponse(exchange);
            message.setBody(response);
        }
    }

    private void createClientRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).roles().create((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client role created successfully");
            }
        } else {
            RoleRepresentation role = new RoleRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME))) {
                String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
                role.setName(roleName);

                if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.ROLE_DESCRIPTION))) {
                    role.setDescription(exchange.getIn().getHeader(KeycloakConstants.ROLE_DESCRIPTION, String.class));
                }
            } else {
                throw new IllegalArgumentException(MISSING_ROLE_NAME);
            }
            keycloakClient.realm(realmName).clients().get(clientUuid).roles().create(role);
            Message message = getMessageForResponse(exchange);
            message.setBody("Client role created successfully");
        }
    }

    private void createClientScope(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientScopeRepresentation) {
                Response response = keycloakClient.realm(realmName).clientScopes().create((ClientScopeRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            ClientScopeRepresentation clientScope = new ClientScopeRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.CLIENT_SCOPE_NAME))) {
                String scopeName = exchange.getIn().getHeader(KeycloakConstants.CLIENT_SCOPE_NAME, String.class);
                clientScope.setName(scopeName);
            } else {
                throw new IllegalArgumentException("Client scope name must be specified");
            }
            Response response = keycloakClient.realm(realmName).clientScopes().create(clientScope);
            Message message = getMessageForResponse(exchange);
            message.setBody(response);
        }
    }

    private void createGroup(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof GroupRepresentation) {
                Response response = keycloakClient.realm(realmName).groups().add((GroupRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            GroupRepresentation group = new GroupRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.GROUP_NAME))) {
                String groupName = exchange.getIn().getHeader(KeycloakConstants.GROUP_NAME, String.class);
                group.setName(groupName);
            } else {
                throw new IllegalArgumentException(MISSING_GROUP_NAME);
            }
            Response response = keycloakClient.realm(realmName).groups().add(group);
            Message message = getMessageForResponse(exchange);
            message.setBody(response);
        }
    }

    private void createClientScope(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientScopeRepresentation) {
                Response response = keycloakClient.realm(realmName).clientScopes().create((ClientScopeRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            ClientScopeRepresentation clientScope = new ClientScopeRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.CLIENT_SCOPE_NAME))) {
                String scopeName = exchange.getIn().getHeader(KeycloakConstants.CLIENT_SCOPE_NAME, String.class);
                clientScope.setName(scopeName);
            } else {
                throw new IllegalArgumentException("Client scope name must be specified");
            }
            Response response = keycloakClient.realm(realmName).clientScopes().create(clientScope);
            Message message = getMessageForResponse(exchange);
            message.setBody(response);
        }
    }

    private void createRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).roles().create((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Role created successfully");
            }
        } else {
            RoleRepresentation role = new RoleRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME))) {
                String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
                role.setName(roleName);

                if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.ROLE_DESCRIPTION))) {
                    role.setDescription(exchange.getIn().getHeader(KeycloakConstants.ROLE_DESCRIPTION, String.class));
                }
            } else {
                throw new IllegalArgumentException(MISSING_ROLE_NAME);
            }
            keycloakClient.realm(realmName).roles().create(role);
            Message message = getMessageForResponse(exchange);
            message.setBody("Role created successfully");
        }
    }

    private void createClientScope(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientScopeRepresentation) {
                Response response = keycloakClient.realm(realmName).clientScopes().create((ClientScopeRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            ClientScopeRepresentation clientScope = new ClientScopeRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.CLIENT_SCOPE_NAME))) {
                String scopeName = exchange.getIn().getHeader(KeycloakConstants.CLIENT_SCOPE_NAME, String.class);
                clientScope.setName(scopeName);
            } else {
                throw new IllegalArgumentException("Client scope name must be specified");
            }
            Response response = keycloakClient.realm(realmName).clientScopes().create(clientScope);
            Message message = getMessageForResponse(exchange);
            message.setBody(response);
        }
    }

    private void createClientRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).roles().create((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client role created successfully");
            }
        } else {
            RoleRepresentation role = new RoleRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME))) {
                String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
                role.setName(roleName);

                if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.ROLE_DESCRIPTION))) {
                    role.setDescription(exchange.getIn().getHeader(KeycloakConstants.ROLE_DESCRIPTION, String.class));
                }
            } else {
                throw new IllegalArgumentException(MISSING_ROLE_NAME);
            }
            keycloakClient.realm(realmName).clients().get(clientUuid).roles().create(role);
            Message message = getMessageForResponse(exchange);
            message.setBody("Client role created successfully");
        }
    }

    private void createGroup(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof GroupRepresentation) {
                Response response = keycloakClient.realm(realmName).groups().add((GroupRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            GroupRepresentation group = new GroupRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.GROUP_NAME))) {
                String groupName = exchange.getIn().getHeader(KeycloakConstants.GROUP_NAME, String.class);
                group.setName(groupName);
            } else {
                throw new IllegalArgumentException(MISSING_GROUP_NAME);
            }
            Response response = keycloakClient.realm(realmName).groups().add(group);
            Message message = getMessageForResponse(exchange);
            message.setBody(response);
        }
    }

    private void createRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).roles().create((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Role created successfully");
            }
        } else {
            RoleRepresentation role = new RoleRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME))) {
                String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
                role.setName(roleName);

                if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.ROLE_DESCRIPTION))) {
                    role.setDescription(exchange.getIn().getHeader(KeycloakConstants.ROLE_DESCRIPTION, String.class));
                }
            } else {
                throw new IllegalArgumentException(MISSING_ROLE_NAME);
            }
            keycloakClient.realm(realmName).roles().create(role);
            Message message = getMessageForResponse(exchange);
            message.setBody("Role created successfully");
        }
    }

    private void createGroup(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof GroupRepresentation) {
                Response response = keycloakClient.realm(realmName).groups().add((GroupRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            GroupRepresentation group = new GroupRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.GROUP_NAME))) {
                String groupName = exchange.getIn().getHeader(KeycloakConstants.GROUP_NAME, String.class);
                group.setName(groupName);
            } else {
                throw new IllegalArgumentException(MISSING_GROUP_NAME);
            }
            Response response = keycloakClient.realm(realmName).groups().add(group);
            Message message = getMessageForResponse(exchange);
            message.setBody(response);
        }
    }

    private void createClientRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).roles().create((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client role created successfully");
            }
        } else {
            RoleRepresentation role = new RoleRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME))) {
                String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
                role.setName(roleName);

                if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.ROLE_DESCRIPTION))) {
                    role.setDescription(exchange.getIn().getHeader(KeycloakConstants.ROLE_DESCRIPTION, String.class));
                }
            } else {
                throw new IllegalArgumentException(MISSING_ROLE_NAME);
            }
            keycloakClient.realm(realmName).clients().get(clientUuid).roles().create(role);
            Message message = getMessageForResponse(exchange);
            message.setBody("Client role created successfully");
        }
    }

    private void createRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).roles().create((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Role created successfully");
            }
        } else {
            RoleRepresentation role = new RoleRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME))) {
                String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
                role.setName(roleName);

                if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.ROLE_DESCRIPTION))) {
                    role.setDescription(exchange.getIn().getHeader(KeycloakConstants.ROLE_DESCRIPTION, String.class));
                }
            } else {
                throw new IllegalArgumentException(MISSING_ROLE_NAME);
            }
            keycloakClient.realm(realmName).roles().create(role);
            Message message = getMessageForResponse(exchange);
            message.setBody("Role created successfully");
        }
    }

    private void createClientRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).roles().create((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client role created successfully");
            }
        } else {
            RoleRepresentation role = new RoleRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME))) {
                String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
                role.setName(roleName);

                if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.ROLE_DESCRIPTION))) {
                    role.setDescription(exchange.getIn().getHeader(KeycloakConstants.ROLE_DESCRIPTION, String.class));
                }
            } else {
                throw new IllegalArgumentException(MISSING_ROLE_NAME);
            }
            keycloakClient.realm(realmName).clients().get(clientUuid).roles().create(role);
            Message message = getMessageForResponse(exchange);
            message.setBody("Client role created successfully");
        }
    }

    private void bulkCreateUsers(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        List<UserRepresentation> users = exchange.getIn().getHeader(KeycloakConstants.USERS, List.class);
        if (users == null || users.isEmpty()) {
             
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof List) {
                users = CastUtils.cast((List<?>) payload);
            } else {
                throw new IllegalArgumentException("Users list must be provided via header or body");
            }
        }

        boolean continueOnError
                = exchange.getIn().getHeader(KeycloakConstants.CONTINUE_ON_ERROR, Boolean.FALSE, Boolean.class);
        List<Map<String, Object>> results = new ArrayList<>();
        int successCount = 0;
        int failureCount = 0;

        for (UserRepresentation user : users) {
            Map<String, Object> result = new HashMap<>();
            result.put("username", user.getUsername());
            try (Response response = keycloakClient.realm(realmName).users().create(user)) {
                result.put("status", "success");
                result.put("statusCode", response.getStatus());
                successCount++;
                response.close();
            } catch (Exception e) {
                result.put("status", "failed");
                result.put("error", e.getMessage());
                failureCount++;
                if (!continueOnError) {
                    throw new RuntimeException("Failed to create user: " + user.getUsername(), e);
                }
            }
            results.add(result);
        }

        Map<String, Object> summary = new HashMap<>();
        summary.put("total", users.size());
        summary.put("success", successCount);
        summary.put("failed", failureCount);
        summary.put("results", results);

        Message message = getMessageForResponse(exchange);
        message.setBody(summary);
    }

    private void bulkUpdateUsers(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        List<UserRepresentation> users = exchange.getIn().getHeader(KeycloakConstants.USERS, List.class);
        if (users == null || users.isEmpty()) {
             
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof List) {
                users = CastUtils.cast((List<?>) payload);
            } else {
                throw new IllegalArgumentException("Users list must be provided via header or body");
            }
        }

        boolean continueOnError
                = exchange.getIn().getHeader(KeycloakConstants.CONTINUE_ON_ERROR, Boolean.FALSE, Boolean.class);
        List<Map<String, Object>> results = new ArrayList<>();
        int successCount = 0;
        int failureCount = 0;

        for (UserRepresentation user : users) {
            Map<String, Object> result = new HashMap<>();
            result.put("userId", user.getId());
            result.put("username", user.getUsername());
            try {
                if (ObjectHelper.isEmpty(user.getId())) {
                    throw new IllegalArgumentException("User ID is required for update operation");
                }
                keycloakClient.realm(realmName).users().get(user.getId()).update(user);
                result.put("status", "success");
                successCount++;
            } catch (Exception e) {
                result.put("status", "failed");
                result.put("error", e.getMessage());
                failureCount++;
                if (!continueOnError) {
                    throw new RuntimeException("Failed to update user: " + user.getId(), e);
                }
            }
            results.add(result);
        }

        Map<String, Object> summary = new HashMap<>();
        summary.put("total", users.size());
        summary.put("success", successCount);
        summary.put("failed", failureCount);
        summary.put("results", results);

        Message message = getMessageForResponse(exchange);
        message.setBody(summary);
    }

    private void bulkCreateUsers(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        List<UserRepresentation> users = exchange.getIn().getHeader(KeycloakConstants.USERS, List.class);
        if (users == null || users.isEmpty()) {
             
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof List) {
                users = CastUtils.cast((List<?>) payload);
            } else {
                throw new IllegalArgumentException("Users list must be provided via header or body");
            }
        }

        boolean continueOnError
                = exchange.getIn().getHeader(KeycloakConstants.CONTINUE_ON_ERROR, Boolean.FALSE, Boolean.class);
        List<Map<String, Object>> results = new ArrayList<>();
        int successCount = 0;
        int failureCount = 0;

        for (UserRepresentation user : users) {
            Map<String, Object> result = new HashMap<>();
            result.put("username", user.getUsername());
            try (Response response = keycloakClient.realm(realmName).users().create(user)) {
                result.put("status", "success");
                result.put("statusCode", response.getStatus());
                successCount++;
                response.close();
            } catch (Exception e) {
                result.put("status", "failed");
                result.put("error", e.getMessage());
                failureCount++;
                if (!continueOnError) {
                    throw new RuntimeException("Failed to create user: " + user.getUsername(), e);
                }
            }
            results.add(result);
        }

        Map<String, Object> summary = new HashMap<>();
        summary.put("total", users.size());
        summary.put("success", successCount);
        summary.put("failed", failureCount);
        summary.put("results", results);

        Message message = getMessageForResponse(exchange);
        message.setBody(summary);
    }

    private void bulkDeleteUsers(Keycloak keycloakClient, Exchange exchange) {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        List<String> userIds = exchange.getIn().getHeader(KeycloakConstants.USER_IDS, List.class);
        if (userIds == null || userIds.isEmpty()) {
             
            List<String> usernames = exchange.getIn().getHeader(KeycloakConstants.USERNAMES, List.class);
            if (usernames == null || usernames.isEmpty()) {
                 
                Object payload = exchange.getIn().getBody();
                if (payload instanceof List) {
                    userIds = CastUtils.cast((List<?>) payload);
                } else {
                    throw new IllegalArgumentException("User IDs or usernames must be provided via header or body");
                }
            } else {
                 
                userIds = new ArrayList<>();
                for (String username : usernames) {
                    List<UserRepresentation> foundUsers
                            = keycloakClient.realm(realmName).users().searchByUsername(username, true);
                    if (!foundUsers.isEmpty()) {
                        userIds.add(foundUsers.get(0).getId());
                    }
                }
            }
        }

        boolean continueOnError
                = exchange.getIn().getHeader(KeycloakConstants.CONTINUE_ON_ERROR, Boolean.FALSE, Boolean.class);
        List<Map<String, Object>> results = new ArrayList<>();
        int successCount = 0;
        int failureCount = 0;

        for (String userId : userIds) {
            Map<String, Object> result = new HashMap<>();
            result.put("userId", userId);
            try {
                Response response = keycloakClient.realm(realmName).users().delete(userId);
                result.put("status", "success");
                result.put("statusCode", response.getStatus());
                successCount++;
                response.close();
            } catch (Exception e) {
                result.put("status", "failed");
                result.put("error", e.getMessage());
                failureCount++;
                if (!continueOnError) {
                    throw new RuntimeException("Failed to delete user: " + userId, e);
                }
            }
            results.add(result);
        }

        Map<String, Object> summary = new HashMap<>();
        summary.put("total", userIds.size());
        summary.put("success", successCount);
        summary.put("failed", failureCount);
        summary.put("results", results);

        Message message = getMessageForResponse(exchange);
        message.setBody(summary);
    }

    private void bulkCreateUsers(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        List<UserRepresentation> users = exchange.getIn().getHeader(KeycloakConstants.USERS, List.class);
        if (users == null || users.isEmpty()) {
             
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof List) {
                users = CastUtils.cast((List<?>) payload);
            } else {
                throw new IllegalArgumentException("Users list must be provided via header or body");
            }
        }

        boolean continueOnError
                = exchange.getIn().getHeader(KeycloakConstants.CONTINUE_ON_ERROR, Boolean.FALSE, Boolean.class);
        List<Map<String, Object>> results = new ArrayList<>();
        int successCount = 0;
        int failureCount = 0;

        for (UserRepresentation user : users) {
            Map<String, Object> result = new HashMap<>();
            result.put("username", user.getUsername());
            try (Response response = keycloakClient.realm(realmName).users().create(user)) {
                result.put("status", "success");
                result.put("statusCode", response.getStatus());
                successCount++;
                response.close();
            } catch (Exception e) {
                result.put("status", "failed");
                result.put("error", e.getMessage());
                failureCount++;
                if (!continueOnError) {
                    throw new RuntimeException("Failed to create user: " + user.getUsername(), e);
                }
            }
            results.add(result);
        }

        Map<String, Object> summary = new HashMap<>();
        summary.put("total", users.size());
        summary.put("success", successCount);
        summary.put("failed", failureCount);
        summary.put("results", results);

        Message message = getMessageForResponse(exchange);
        message.setBody(summary);
    }

    private void bulkAssignRolesToUser(Keycloak keycloakClient, Exchange exchange) {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String userId = exchange.getIn().getHeader(KeycloakConstants.USER_ID, String.class);
        if (ObjectHelper.isEmpty(userId)) {
            throw new IllegalArgumentException(MISSING_USER_ID);
        }

        List<String> roleNames = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAMES, List.class);
        if (roleNames == null || roleNames.isEmpty()) {
             
            Object payload = exchange.getIn().getBody();
            if (payload instanceof List) {
                roleNames = CastUtils.cast((List<?>) payload);
            } else {
                throw new IllegalArgumentException("Role names must be provided via header or body");
            }
        }

        boolean continueOnError
                = exchange.getIn().getHeader(KeycloakConstants.CONTINUE_ON_ERROR, Boolean.FALSE, Boolean.class);
        List<Map<String, Object>> results = new ArrayList<>();
        List<RoleRepresentation> rolesToAssign = new ArrayList<>();
        int successCount = 0;
        int failureCount = 0;

         
        for (String roleName : roleNames) {
            Map<String, Object> result = new HashMap<>();
            result.put("roleName", roleName);
            try {
                RoleRepresentation role = keycloakClient.realm(realmName).roles().get(roleName).toRepresentation();
                rolesToAssign.add(role);
                result.put("status", "found");
                successCount++;
            } catch (Exception e) {
                result.put("status", "not_found");
                result.put("error", e.getMessage());
                failureCount++;
                if (!continueOnError) {
                    throw new RuntimeException("Failed to find role: " + roleName, e);
                }
            }
            results.add(result);
        }

         
        if (!rolesToAssign.isEmpty()) {
            try {
                keycloakClient.realm(realmName).users().get(userId).roles().realmLevel().add(rolesToAssign);
            } catch (Exception e) {
                throw new RuntimeException("Failed to assign roles to user: " + userId, e);
            }
        }

        Map<String, Object> summary = new HashMap<>();
        summary.put("total", roleNames.size());
        summary.put("success", successCount);
        summary.put("failed", failureCount);
        summary.put("assigned", rolesToAssign.size());
        summary.put("results", results);

        Message message = getMessageForResponse(exchange);
        message.setBody(summary);
    }

    private void bulkCreateUsers(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        List<UserRepresentation> users = exchange.getIn().getHeader(KeycloakConstants.USERS, List.class);
        if (users == null || users.isEmpty()) {
             
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof List) {
                users = CastUtils.cast((List<?>) payload);
            } else {
                throw new IllegalArgumentException("Users list must be provided via header or body");
            }
        }

        boolean continueOnError
                = exchange.getIn().getHeader(KeycloakConstants.CONTINUE_ON_ERROR, Boolean.FALSE, Boolean.class);
        List<Map<String, Object>> results = new ArrayList<>();
        int successCount = 0;
        int failureCount = 0;

        for (UserRepresentation user : users) {
            Map<String, Object> result = new HashMap<>();
            result.put("username", user.getUsername());
            try (Response response = keycloakClient.realm(realmName).users().create(user)) {
                result.put("status", "success");
                result.put("statusCode", response.getStatus());
                successCount++;
                response.close();
            } catch (Exception e) {
                result.put("status", "failed");
                result.put("error", e.getMessage());
                failureCount++;
                if (!continueOnError) {
                    throw new RuntimeException("Failed to create user: " + user.getUsername(), e);
                }
            }
            results.add(result);
        }

        Map<String, Object> summary = new HashMap<>();
        summary.put("total", users.size());
        summary.put("success", successCount);
        summary.put("failed", failureCount);
        summary.put("results", results);

        Message message = getMessageForResponse(exchange);
        message.setBody(summary);
    }

    private void bulkAssignRoleToUsers(Keycloak keycloakClient, Exchange exchange) {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
        if (ObjectHelper.isEmpty(roleName)) {
            throw new IllegalArgumentException(MISSING_ROLE_NAME);
        }

         
        RoleRepresentation role;
        try {
            role = keycloakClient.realm(realmName).roles().get(roleName).toRepresentation();
        } catch (Exception e) {
            throw new RuntimeException("Failed to find role: " + roleName, e);
        }

        List<String> userIds = exchange.getIn().getHeader(KeycloakConstants.USER_IDS, List.class);
        if (userIds == null || userIds.isEmpty()) {
             
            List<String> usernames = exchange.getIn().getHeader(KeycloakConstants.USERNAMES, List.class);
            if (usernames == null || usernames.isEmpty()) {
                 
                Object payload = exchange.getIn().getBody();
                if (payload instanceof List) {
                    userIds = CastUtils.cast((List<?>) payload);
                } else {
                    throw new IllegalArgumentException("User IDs or usernames must be provided via header or body");
                }
            } else {
                 
                userIds = new ArrayList<>();
                for (String username : usernames) {
                    List<UserRepresentation> foundUsers
                            = keycloakClient.realm(realmName).users().searchByUsername(username, true);
                    if (!foundUsers.isEmpty()) {
                        userIds.add(foundUsers.get(0).getId());
                    }
                }
            }
        }

        boolean continueOnError
                = exchange.getIn().getHeader(KeycloakConstants.CONTINUE_ON_ERROR, Boolean.FALSE, Boolean.class);
        List<Map<String, Object>> results = new ArrayList<>();
        int successCount = 0;
        int failureCount = 0;

        for (String userId : userIds) {
            Map<String, Object> result = new HashMap<>();
            result.put("userId", userId);
            try {
                keycloakClient.realm(realmName).users().get(userId).roles().realmLevel().add(List.of(role));
                result.put("status", "success");
                successCount++;
            } catch (Exception e) {
                result.put("status", "failed");
                result.put("error", e.getMessage());
                failureCount++;
                if (!continueOnError) {
                    throw new RuntimeException("Failed to assign role to user: " + userId, e);
                }
            }
            results.add(result);
        }

        Map<String, Object> summary = new HashMap<>();
        summary.put("total", userIds.size());
        summary.put("success", successCount);
        summary.put("failed", failureCount);
        summary.put("roleName", roleName);
        summary.put("results", results);

        Message message = getMessageForResponse(exchange);
        message.setBody(summary);
    }

    private void bulkUpdateUsers(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        List<UserRepresentation> users = exchange.getIn().getHeader(KeycloakConstants.USERS, List.class);
        if (users == null || users.isEmpty()) {
             
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof List) {
                users = CastUtils.cast((List<?>) payload);
            } else {
                throw new IllegalArgumentException("Users list must be provided via header or body");
            }
        }

        boolean continueOnError
                = exchange.getIn().getHeader(KeycloakConstants.CONTINUE_ON_ERROR, Boolean.FALSE, Boolean.class);
        List<Map<String, Object>> results = new ArrayList<>();
        int successCount = 0;
        int failureCount = 0;

        for (UserRepresentation user : users) {
            Map<String, Object> result = new HashMap<>();
            result.put("userId", user.getId());
            result.put("username", user.getUsername());
            try {
                if (ObjectHelper.isEmpty(user.getId())) {
                    throw new IllegalArgumentException("User ID is required for update operation");
                }
                keycloakClient.realm(realmName).users().get(user.getId()).update(user);
                result.put("status", "success");
                successCount++;
            } catch (Exception e) {
                result.put("status", "failed");
                result.put("error", e.getMessage());
                failureCount++;
                if (!continueOnError) {
                    throw new RuntimeException("Failed to update user: " + user.getId(), e);
                }
            }
            results.add(result);
        }

        Map<String, Object> summary = new HashMap<>();
        summary.put("total", users.size());
        summary.put("success", successCount);
        summary.put("failed", failureCount);
        summary.put("results", results);

        Message message = getMessageForResponse(exchange);
        message.setBody(summary);
    }

    private void bulkDeleteUsers(Keycloak keycloakClient, Exchange exchange) {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        List<String> userIds = exchange.getIn().getHeader(KeycloakConstants.USER_IDS, List.class);
        if (userIds == null || userIds.isEmpty()) {
             
            List<String> usernames = exchange.getIn().getHeader(KeycloakConstants.USERNAMES, List.class);
            if (usernames == null || usernames.isEmpty()) {
                 
                Object payload = exchange.getIn().getBody();
                if (payload instanceof List) {
                    userIds = CastUtils.cast((List<?>) payload);
                } else {
                    throw new IllegalArgumentException("User IDs or usernames must be provided via header or body");
                }
            } else {
                 
                userIds = new ArrayList<>();
                for (String username : usernames) {
                    List<UserRepresentation> foundUsers
                            = keycloakClient.realm(realmName).users().searchByUsername(username, true);
                    if (!foundUsers.isEmpty()) {
                        userIds.add(foundUsers.get(0).getId());
                    }
                }
            }
        }

        boolean continueOnError
                = exchange.getIn().getHeader(KeycloakConstants.CONTINUE_ON_ERROR, Boolean.FALSE, Boolean.class);
        List<Map<String, Object>> results = new ArrayList<>();
        int successCount = 0;
        int failureCount = 0;

        for (String userId : userIds) {
            Map<String, Object> result = new HashMap<>();
            result.put("userId", userId);
            try {
                Response response = keycloakClient.realm(realmName).users().delete(userId);
                result.put("status", "success");
                result.put("statusCode", response.getStatus());
                successCount++;
                response.close();
            } catch (Exception e) {
                result.put("status", "failed");
                result.put("error", e.getMessage());
                failureCount++;
                if (!continueOnError) {
                    throw new RuntimeException("Failed to delete user: " + userId, e);
                }
            }
            results.add(result);
        }

        Map<String, Object> summary = new HashMap<>();
        summary.put("total", userIds.size());
        summary.put("success", successCount);
        summary.put("failed", failureCount);
        summary.put("results", results);

        Message message = getMessageForResponse(exchange);
        message.setBody(summary);
    }

    private void bulkUpdateUsers(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        List<UserRepresentation> users = exchange.getIn().getHeader(KeycloakConstants.USERS, List.class);
        if (users == null || users.isEmpty()) {
             
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof List) {
                users = CastUtils.cast((List<?>) payload);
            } else {
                throw new IllegalArgumentException("Users list must be provided via header or body");
            }
        }

        boolean continueOnError
                = exchange.getIn().getHeader(KeycloakConstants.CONTINUE_ON_ERROR, Boolean.FALSE, Boolean.class);
        List<Map<String, Object>> results = new ArrayList<>();
        int successCount = 0;
        int failureCount = 0;

        for (UserRepresentation user : users) {
            Map<String, Object> result = new HashMap<>();
            result.put("userId", user.getId());
            result.put("username", user.getUsername());
            try {
                if (ObjectHelper.isEmpty(user.getId())) {
                    throw new IllegalArgumentException("User ID is required for update operation");
                }
                keycloakClient.realm(realmName).users().get(user.getId()).update(user);
                result.put("status", "success");
                successCount++;
            } catch (Exception e) {
                result.put("status", "failed");
                result.put("error", e.getMessage());
                failureCount++;
                if (!continueOnError) {
                    throw new RuntimeException("Failed to update user: " + user.getId(), e);
                }
            }
            results.add(result);
        }

        Map<String, Object> summary = new HashMap<>();
        summary.put("total", users.size());
        summary.put("success", successCount);
        summary.put("failed", failureCount);
        summary.put("results", results);

        Message message = getMessageForResponse(exchange);
        message.setBody(summary);
    }

    private void bulkAssignRolesToUser(Keycloak keycloakClient, Exchange exchange) {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String userId = exchange.getIn().getHeader(KeycloakConstants.USER_ID, String.class);
        if (ObjectHelper.isEmpty(userId)) {
            throw new IllegalArgumentException(MISSING_USER_ID);
        }

        List<String> roleNames = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAMES, List.class);
        if (roleNames == null || roleNames.isEmpty()) {
             
            Object payload = exchange.getIn().getBody();
            if (payload instanceof List) {
                roleNames = CastUtils.cast((List<?>) payload);
            } else {
                throw new IllegalArgumentException("Role names must be provided via header or body");
            }
        }

        boolean continueOnError
                = exchange.getIn().getHeader(KeycloakConstants.CONTINUE_ON_ERROR, Boolean.FALSE, Boolean.class);
        List<Map<String, Object>> results = new ArrayList<>();
        List<RoleRepresentation> rolesToAssign = new ArrayList<>();
        int successCount = 0;
        int failureCount = 0;

         
        for (String roleName : roleNames) {
            Map<String, Object> result = new HashMap<>();
            result.put("roleName", roleName);
            try {
                RoleRepresentation role = keycloakClient.realm(realmName).roles().get(roleName).toRepresentation();
                rolesToAssign.add(role);
                result.put("status", "found");
                successCount++;
            } catch (Exception e) {
                result.put("status", "not_found");
                result.put("error", e.getMessage());
                failureCount++;
                if (!continueOnError) {
                    throw new RuntimeException("Failed to find role: " + roleName, e);
                }
            }
            results.add(result);
        }

         
        if (!rolesToAssign.isEmpty()) {
            try {
                keycloakClient.realm(realmName).users().get(userId).roles().realmLevel().add(rolesToAssign);
            } catch (Exception e) {
                throw new RuntimeException("Failed to assign roles to user: " + userId, e);
            }
        }

        Map<String, Object> summary = new HashMap<>();
        summary.put("total", roleNames.size());
        summary.put("success", successCount);
        summary.put("failed", failureCount);
        summary.put("assigned", rolesToAssign.size());
        summary.put("results", results);

        Message message = getMessageForResponse(exchange);
        message.setBody(summary);
    }

    private void bulkUpdateUsers(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        List<UserRepresentation> users = exchange.getIn().getHeader(KeycloakConstants.USERS, List.class);
        if (users == null || users.isEmpty()) {
             
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof List) {
                users = CastUtils.cast((List<?>) payload);
            } else {
                throw new IllegalArgumentException("Users list must be provided via header or body");
            }
        }

        boolean continueOnError
                = exchange.getIn().getHeader(KeycloakConstants.CONTINUE_ON_ERROR, Boolean.FALSE, Boolean.class);
        List<Map<String, Object>> results = new ArrayList<>();
        int successCount = 0;
        int failureCount = 0;

        for (UserRepresentation user : users) {
            Map<String, Object> result = new HashMap<>();
            result.put("userId", user.getId());
            result.put("username", user.getUsername());
            try {
                if (ObjectHelper.isEmpty(user.getId())) {
                    throw new IllegalArgumentException("User ID is required for update operation");
                }
                keycloakClient.realm(realmName).users().get(user.getId()).update(user);
                result.put("status", "success");
                successCount++;
            } catch (Exception e) {
                result.put("status", "failed");
                result.put("error", e.getMessage());
                failureCount++;
                if (!continueOnError) {
                    throw new RuntimeException("Failed to update user: " + user.getId(), e);
                }
            }
            results.add(result);
        }

        Map<String, Object> summary = new HashMap<>();
        summary.put("total", users.size());
        summary.put("success", successCount);
        summary.put("failed", failureCount);
        summary.put("results", results);

        Message message = getMessageForResponse(exchange);
        message.setBody(summary);
    }

    private void bulkAssignRoleToUsers(Keycloak keycloakClient, Exchange exchange) {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
        if (ObjectHelper.isEmpty(roleName)) {
            throw new IllegalArgumentException(MISSING_ROLE_NAME);
        }

         
        RoleRepresentation role;
        try {
            role = keycloakClient.realm(realmName).roles().get(roleName).toRepresentation();
        } catch (Exception e) {
            throw new RuntimeException("Failed to find role: " + roleName, e);
        }

        List<String> userIds = exchange.getIn().getHeader(KeycloakConstants.USER_IDS, List.class);
        if (userIds == null || userIds.isEmpty()) {
             
            List<String> usernames = exchange.getIn().getHeader(KeycloakConstants.USERNAMES, List.class);
            if (usernames == null || usernames.isEmpty()) {
                 
                Object payload = exchange.getIn().getBody();
                if (payload instanceof List) {
                    userIds = CastUtils.cast((List<?>) payload);
                } else {
                    throw new IllegalArgumentException("User IDs or usernames must be provided via header or body");
                }
            } else {
                 
                userIds = new ArrayList<>();
                for (String username : usernames) {
                    List<UserRepresentation> foundUsers
                            = keycloakClient.realm(realmName).users().searchByUsername(username, true);
                    if (!foundUsers.isEmpty()) {
                        userIds.add(foundUsers.get(0).getId());
                    }
                }
            }
        }

        boolean continueOnError
                = exchange.getIn().getHeader(KeycloakConstants.CONTINUE_ON_ERROR, Boolean.FALSE, Boolean.class);
        List<Map<String, Object>> results = new ArrayList<>();
        int successCount = 0;
        int failureCount = 0;

        for (String userId : userIds) {
            Map<String, Object> result = new HashMap<>();
            result.put("userId", userId);
            try {
                keycloakClient.realm(realmName).users().get(userId).roles().realmLevel().add(List.of(role));
                result.put("status", "success");
                successCount++;
            } catch (Exception e) {
                result.put("status", "failed");
                result.put("error", e.getMessage());
                failureCount++;
                if (!continueOnError) {
                    throw new RuntimeException("Failed to assign role to user: " + userId, e);
                }
            }
            results.add(result);
        }

        Map<String, Object> summary = new HashMap<>();
        summary.put("total", userIds.size());
        summary.put("success", successCount);
        summary.put("failed", failureCount);
        summary.put("roleName", roleName);
        summary.put("results", results);

        Message message = getMessageForResponse(exchange);
        message.setBody(summary);
    }

    private void bulkDeleteUsers(Keycloak keycloakClient, Exchange exchange) {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        List<String> userIds = exchange.getIn().getHeader(KeycloakConstants.USER_IDS, List.class);
        if (userIds == null || userIds.isEmpty()) {
             
            List<String> usernames = exchange.getIn().getHeader(KeycloakConstants.USERNAMES, List.class);
            if (usernames == null || usernames.isEmpty()) {
                 
                Object payload = exchange.getIn().getBody();
                if (payload instanceof List) {
                    userIds = CastUtils.cast((List<?>) payload);
                } else {
                    throw new IllegalArgumentException("User IDs or usernames must be provided via header or body");
                }
            } else {
                 
                userIds = new ArrayList<>();
                for (String username : usernames) {
                    List<UserRepresentation> foundUsers
                            = keycloakClient.realm(realmName).users().searchByUsername(username, true);
                    if (!foundUsers.isEmpty()) {
                        userIds.add(foundUsers.get(0).getId());
                    }
                }
            }
        }

        boolean continueOnError
                = exchange.getIn().getHeader(KeycloakConstants.CONTINUE_ON_ERROR, Boolean.FALSE, Boolean.class);
        List<Map<String, Object>> results = new ArrayList<>();
        int successCount = 0;
        int failureCount = 0;

        for (String userId : userIds) {
            Map<String, Object> result = new HashMap<>();
            result.put("userId", userId);
            try {
                Response response = keycloakClient.realm(realmName).users().delete(userId);
                result.put("status", "success");
                result.put("statusCode", response.getStatus());
                successCount++;
                response.close();
            } catch (Exception e) {
                result.put("status", "failed");
                result.put("error", e.getMessage());
                failureCount++;
                if (!continueOnError) {
                    throw new RuntimeException("Failed to delete user: " + userId, e);
                }
            }
            results.add(result);
        }

        Map<String, Object> summary = new HashMap<>();
        summary.put("total", userIds.size());
        summary.put("success", successCount);
        summary.put("failed", failureCount);
        summary.put("results", results);

        Message message = getMessageForResponse(exchange);
        message.setBody(summary);
    }

    private void bulkAssignRolesToUser(Keycloak keycloakClient, Exchange exchange) {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String userId = exchange.getIn().getHeader(KeycloakConstants.USER_ID, String.class);
        if (ObjectHelper.isEmpty(userId)) {
            throw new IllegalArgumentException(MISSING_USER_ID);
        }

        List<String> roleNames = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAMES, List.class);
        if (roleNames == null || roleNames.isEmpty()) {
             
            Object payload = exchange.getIn().getBody();
            if (payload instanceof List) {
                roleNames = CastUtils.cast((List<?>) payload);
            } else {
                throw new IllegalArgumentException("Role names must be provided via header or body");
            }
        }

        boolean continueOnError
                = exchange.getIn().getHeader(KeycloakConstants.CONTINUE_ON_ERROR, Boolean.FALSE, Boolean.class);
        List<Map<String, Object>> results = new ArrayList<>();
        List<RoleRepresentation> rolesToAssign = new ArrayList<>();
        int successCount = 0;
        int failureCount = 0;

         
        for (String roleName : roleNames) {
            Map<String, Object> result = new HashMap<>();
            result.put("roleName", roleName);
            try {
                RoleRepresentation role = keycloakClient.realm(realmName).roles().get(roleName).toRepresentation();
                rolesToAssign.add(role);
                result.put("status", "found");
                successCount++;
            } catch (Exception e) {
                result.put("status", "not_found");
                result.put("error", e.getMessage());
                failureCount++;
                if (!continueOnError) {
                    throw new RuntimeException("Failed to find role: " + roleName, e);
                }
            }
            results.add(result);
        }

         
        if (!rolesToAssign.isEmpty()) {
            try {
                keycloakClient.realm(realmName).users().get(userId).roles().realmLevel().add(rolesToAssign);
            } catch (Exception e) {
                throw new RuntimeException("Failed to assign roles to user: " + userId, e);
            }
        }

        Map<String, Object> summary = new HashMap<>();
        summary.put("total", roleNames.size());
        summary.put("success", successCount);
        summary.put("failed", failureCount);
        summary.put("assigned", rolesToAssign.size());
        summary.put("results", results);

        Message message = getMessageForResponse(exchange);
        message.setBody(summary);
    }

    private void bulkDeleteUsers(Keycloak keycloakClient, Exchange exchange) {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        List<String> userIds = exchange.getIn().getHeader(KeycloakConstants.USER_IDS, List.class);
        if (userIds == null || userIds.isEmpty()) {
             
            List<String> usernames = exchange.getIn().getHeader(KeycloakConstants.USERNAMES, List.class);
            if (usernames == null || usernames.isEmpty()) {
                 
                Object payload = exchange.getIn().getBody();
                if (payload instanceof List) {
                    userIds = CastUtils.cast((List<?>) payload);
                } else {
                    throw new IllegalArgumentException("User IDs or usernames must be provided via header or body");
                }
            } else {
                 
                userIds = new ArrayList<>();
                for (String username : usernames) {
                    List<UserRepresentation> foundUsers
                            = keycloakClient.realm(realmName).users().searchByUsername(username, true);
                    if (!foundUsers.isEmpty()) {
                        userIds.add(foundUsers.get(0).getId());
                    }
                }
            }
        }

        boolean continueOnError
                = exchange.getIn().getHeader(KeycloakConstants.CONTINUE_ON_ERROR, Boolean.FALSE, Boolean.class);
        List<Map<String, Object>> results = new ArrayList<>();
        int successCount = 0;
        int failureCount = 0;

        for (String userId : userIds) {
            Map<String, Object> result = new HashMap<>();
            result.put("userId", userId);
            try {
                Response response = keycloakClient.realm(realmName).users().delete(userId);
                result.put("status", "success");
                result.put("statusCode", response.getStatus());
                successCount++;
                response.close();
            } catch (Exception e) {
                result.put("status", "failed");
                result.put("error", e.getMessage());
                failureCount++;
                if (!continueOnError) {
                    throw new RuntimeException("Failed to delete user: " + userId, e);
                }
            }
            results.add(result);
        }

        Map<String, Object> summary = new HashMap<>();
        summary.put("total", userIds.size());
        summary.put("success", successCount);
        summary.put("failed", failureCount);
        summary.put("results", results);

        Message message = getMessageForResponse(exchange);
        message.setBody(summary);
    }

    private void bulkAssignRoleToUsers(Keycloak keycloakClient, Exchange exchange) {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
        if (ObjectHelper.isEmpty(roleName)) {
            throw new IllegalArgumentException(MISSING_ROLE_NAME);
        }

         
        RoleRepresentation role;
        try {
            role = keycloakClient.realm(realmName).roles().get(roleName).toRepresentation();
        } catch (Exception e) {
            throw new RuntimeException("Failed to find role: " + roleName, e);
        }

        List<String> userIds = exchange.getIn().getHeader(KeycloakConstants.USER_IDS, List.class);
        if (userIds == null || userIds.isEmpty()) {
             
            List<String> usernames = exchange.getIn().getHeader(KeycloakConstants.USERNAMES, List.class);
            if (usernames == null || usernames.isEmpty()) {
                 
                Object payload = exchange.getIn().getBody();
                if (payload instanceof List) {
                    userIds = CastUtils.cast((List<?>) payload);
                } else {
                    throw new IllegalArgumentException("User IDs or usernames must be provided via header or body");
                }
            } else {
                 
                userIds = new ArrayList<>();
                for (String username : usernames) {
                    List<UserRepresentation> foundUsers
                            = keycloakClient.realm(realmName).users().searchByUsername(username, true);
                    if (!foundUsers.isEmpty()) {
                        userIds.add(foundUsers.get(0).getId());
                    }
                }
            }
        }

        boolean continueOnError
                = exchange.getIn().getHeader(KeycloakConstants.CONTINUE_ON_ERROR, Boolean.FALSE, Boolean.class);
        List<Map<String, Object>> results = new ArrayList<>();
        int successCount = 0;
        int failureCount = 0;

        for (String userId : userIds) {
            Map<String, Object> result = new HashMap<>();
            result.put("userId", userId);
            try {
                keycloakClient.realm(realmName).users().get(userId).roles().realmLevel().add(List.of(role));
                result.put("status", "success");
                successCount++;
            } catch (Exception e) {
                result.put("status", "failed");
                result.put("error", e.getMessage());
                failureCount++;
                if (!continueOnError) {
                    throw new RuntimeException("Failed to assign role to user: " + userId, e);
                }
            }
            results.add(result);
        }

        Map<String, Object> summary = new HashMap<>();
        summary.put("total", userIds.size());
        summary.put("success", successCount);
        summary.put("failed", failureCount);
        summary.put("roleName", roleName);
        summary.put("results", results);

        Message message = getMessageForResponse(exchange);
        message.setBody(summary);
    }

    private void bulkAssignRolesToUser(Keycloak keycloakClient, Exchange exchange) {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String userId = exchange.getIn().getHeader(KeycloakConstants.USER_ID, String.class);
        if (ObjectHelper.isEmpty(userId)) {
            throw new IllegalArgumentException(MISSING_USER_ID);
        }

        List<String> roleNames = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAMES, List.class);
        if (roleNames == null || roleNames.isEmpty()) {
             
            Object payload = exchange.getIn().getBody();
            if (payload instanceof List) {
                roleNames = CastUtils.cast((List<?>) payload);
            } else {
                throw new IllegalArgumentException("Role names must be provided via header or body");
            }
        }

        boolean continueOnError
                = exchange.getIn().getHeader(KeycloakConstants.CONTINUE_ON_ERROR, Boolean.FALSE, Boolean.class);
        List<Map<String, Object>> results = new ArrayList<>();
        List<RoleRepresentation> rolesToAssign = new ArrayList<>();
        int successCount = 0;
        int failureCount = 0;

         
        for (String roleName : roleNames) {
            Map<String, Object> result = new HashMap<>();
            result.put("roleName", roleName);
            try {
                RoleRepresentation role = keycloakClient.realm(realmName).roles().get(roleName).toRepresentation();
                rolesToAssign.add(role);
                result.put("status", "found");
                successCount++;
            } catch (Exception e) {
                result.put("status", "not_found");
                result.put("error", e.getMessage());
                failureCount++;
                if (!continueOnError) {
                    throw new RuntimeException("Failed to find role: " + roleName, e);
                }
            }
            results.add(result);
        }

         
        if (!rolesToAssign.isEmpty()) {
            try {
                keycloakClient.realm(realmName).users().get(userId).roles().realmLevel().add(rolesToAssign);
            } catch (Exception e) {
                throw new RuntimeException("Failed to assign roles to user: " + userId, e);
            }
        }

        Map<String, Object> summary = new HashMap<>();
        summary.put("total", roleNames.size());
        summary.put("success", successCount);
        summary.put("failed", failureCount);
        summary.put("assigned", rolesToAssign.size());
        summary.put("results", results);

        Message message = getMessageForResponse(exchange);
        message.setBody(summary);
    }

    private void bulkAssignRoleToUsers(Keycloak keycloakClient, Exchange exchange) {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
        if (ObjectHelper.isEmpty(roleName)) {
            throw new IllegalArgumentException(MISSING_ROLE_NAME);
        }

         
        RoleRepresentation role;
        try {
            role = keycloakClient.realm(realmName).roles().get(roleName).toRepresentation();
        } catch (Exception e) {
            throw new RuntimeException("Failed to find role: " + roleName, e);
        }

        List<String> userIds = exchange.getIn().getHeader(KeycloakConstants.USER_IDS, List.class);
        if (userIds == null || userIds.isEmpty()) {
             
            List<String> usernames = exchange.getIn().getHeader(KeycloakConstants.USERNAMES, List.class);
            if (usernames == null || usernames.isEmpty()) {
                 
                Object payload = exchange.getIn().getBody();
                if (payload instanceof List) {
                    userIds = CastUtils.cast((List<?>) payload);
                } else {
                    throw new IllegalArgumentException("User IDs or usernames must be provided via header or body");
                }
            } else {
                 
                userIds = new ArrayList<>();
                for (String username : usernames) {
                    List<UserRepresentation> foundUsers
                            = keycloakClient.realm(realmName).users().searchByUsername(username, true);
                    if (!foundUsers.isEmpty()) {
                        userIds.add(foundUsers.get(0).getId());
                    }
                }
            }
        }

        boolean continueOnError
                = exchange.getIn().getHeader(KeycloakConstants.CONTINUE_ON_ERROR, Boolean.FALSE, Boolean.class);
        List<Map<String, Object>> results = new ArrayList<>();
        int successCount = 0;
        int failureCount = 0;

        for (String userId : userIds) {
            Map<String, Object> result = new HashMap<>();
            result.put("userId", userId);
            try {
                keycloakClient.realm(realmName).users().get(userId).roles().realmLevel().add(List.of(role));
                result.put("status", "success");
                successCount++;
            } catch (Exception e) {
                result.put("status", "failed");
                result.put("error", e.getMessage());
                failureCount++;
                if (!continueOnError) {
                    throw new RuntimeException("Failed to assign role to user: " + userId, e);
                }
            }
            results.add(result);
        }

        Map<String, Object> summary = new HashMap<>();
        summary.put("total", userIds.size());
        summary.put("success", successCount);
        summary.put("failed", failureCount);
        summary.put("roleName", roleName);
        summary.put("results", results);

        Message message = getMessageForResponse(exchange);
        message.setBody(summary);
    }

    private Queue<Exchange> pollEvents() throws Exception {
        Keycloak keycloakClient = getEndpoint().getKeycloakClient();
        KeycloakConfiguration config = getEndpoint().getConfiguration();
        String realm = config.getRealm();

        if (realm == null) {
            throw new IllegalArgumentException("Realm must be specified for consuming events");
        }

         
         
         
        List<String> eventTypes = parseCommaSeparatedList(config.getTypes());
        List<EventRepresentation> events = keycloakClient.realm(realm).getEvents(
                eventTypes,  
                config.getClient(),  
                config.getUser(),  
                config.getDateFrom(),  
                config.getDateTo(),  
                config.getIpAddress(),  
                config.getFirst(),  
                config.getMaxResults()  
        );

        Queue<Exchange> queue = new LinkedList<>();
        long highestEventTime = lastEventTime != null ? lastEventTime : 0;

        for (EventRepresentation event : events) {
            long eventTime = event.getTime();

             
            if (lastEventTime != null && eventTime < lastEventTime) {
                continue;
            }

             
            String fingerprint = getEventFingerprint(event);

             
            if (processedEventFingerprints.contains(fingerprint)) {
                LOG.trace("Skipping already processed event: {}", fingerprint);
                continue;
            }

            Exchange exchange = createExchange(false);
            exchange.getIn().setBody(event);
            exchange.getIn().setHeader(KeycloakConstants.EVENT_TYPE, "event");
            exchange.getIn().setHeader(KeycloakConstants.EVENT_ID, event.getTime());
            exchange.getIn().setHeader(KeycloakConstants.REALM_NAME, realm);
            queue.add(exchange);

             
            processedEventFingerprints.add(fingerprint);

             
            if (eventTime > highestEventTime) {
                highestEventTime = eventTime;
            }

             
            if (processedEventFingerprints.size() > MAX_FINGERPRINT_CACHE_SIZE) {
                processedEventFingerprints.clear();
                LOG.debug("Cleared fingerprint cache due to size limit");
            }
        }

         
        if (highestEventTime > (lastEventTime != null ? lastEventTime : 0)) {
             
            processedEventFingerprints.clear();
            lastEventTime = highestEventTime;
            LOG.debug("Updated last event time to: {}", lastEventTime);
        }

        return queue;
    }

    private Queue<Exchange> pollAdminEvents() throws Exception {
        Keycloak keycloakClient = getEndpoint().getKeycloakClient();
        KeycloakConfiguration config = getEndpoint().getConfiguration();
        String realm = config.getRealm();

        if (realm == null) {
            throw new IllegalArgumentException("Realm must be specified for consuming admin events");
        }

         
         
         
        List<String> adminOperationTypes = parseCommaSeparatedList(config.getOperationTypes());
        List<AdminEventRepresentation> adminEvents = keycloakClient.realm(realm).getAdminEvents(
                adminOperationTypes,  
                config.getAuthRealmFilter(),  
                config.getAuthClient(),  
                config.getAuthUser(),  
                config.getAuthIpAddress(),  
                config.getResourcePath(),  
                config.getDateFrom(),  
                config.getDateTo(),  
                config.getFirst(),  
                config.getMaxResults()  
        );

        Queue<Exchange> queue = new LinkedList<>();
        long highestEventTime = lastEventTime != null ? lastEventTime : 0;

        for (AdminEventRepresentation adminEvent : adminEvents) {
            long eventTime = adminEvent.getTime();

             
            if (lastEventTime != null && eventTime < lastEventTime) {
                continue;
            }

             
            String fingerprint = getAdminEventFingerprint(adminEvent);

             
            if (processedEventFingerprints.contains(fingerprint)) {
                LOG.trace("Skipping already processed admin event: {}", fingerprint);
                continue;
            }

            Exchange exchange = createExchange(false);
            exchange.getIn().setBody(adminEvent);
            exchange.getIn().setHeader(KeycloakConstants.EVENT_TYPE, "admin-event");
            exchange.getIn().setHeader(KeycloakConstants.EVENT_ID, adminEvent.getTime());
            exchange.getIn().setHeader(KeycloakConstants.REALM_NAME, realm);
            queue.add(exchange);

             
            processedEventFingerprints.add(fingerprint);

             
            if (eventTime > highestEventTime) {
                highestEventTime = eventTime;
            }

             
            if (processedEventFingerprints.size() > MAX_FINGERPRINT_CACHE_SIZE) {
                 
                 
                processedEventFingerprints.clear();
                LOG.debug("Cleared fingerprint cache due to size limit");
            }
        }

         
        if (highestEventTime > (lastEventTime != null ? lastEventTime : 0)) {
             
            processedEventFingerprints.clear();
            lastEventTime = highestEventTime;
            LOG.debug("Updated last admin event time to: {}", lastEventTime);
        }

        return queue;
    }

    public boolean register(PlatformHttpPlugin plugin) {
        if (getPlugin(plugin.getId()).isPresent()) {
            return false;
        }

        boolean result = plugins.add(plugin);
        if (result) {
            CamelContextAware.trySetCamelContext(plugin, camelContext);
            ServiceHelper.startService(plugin);
            LOG.debug("platform-http-plugin with id {} successfully registered", plugin.getId());
        }
        return result;
    }

    public boolean register(DevConsole console) {
        boolean result;
         
        if (getConsole(console.getId()).isPresent()) {
            return false;
        }
        result = consoles.add(console);
        if (result) {
            CamelContextAware.trySetCamelContext(console, camelContext);
             
            ServiceHelper.startService(console);
            LOG.debug("DevConsole with id {} successfully registered", console.getId());
        }
        return result;
    }

    protected void doInit() throws Exception {
        super.doInit();

        try {
            RestConfiguration config = CamelContextHelper.getRestConfiguration(getCamelContext(), "platform-http");

             
            if (config.getComponentProperties() != null && !config.getComponentProperties().isEmpty()) {
                setProperties(this, config.getComponentProperties());
            }
        } catch (IllegalArgumentException e) {
             
             
             
        }
    }

    protected void doInit() throws Exception {
        super.doInit();

        try {
            RestConfiguration config = CamelContextHelper.getRestConfiguration(getCamelContext(), "servlet");

             
            if (config.getComponentProperties() != null && !config.getComponentProperties().isEmpty()) {
                setProperties(this, config.getComponentProperties());
            }
        } catch (IllegalArgumentException e) {
             
             
             
        }
    }

    protected void doInit() throws Exception {
        super.doInit();

        try {
            RestConfiguration config = CamelContextHelper.getRestConfiguration(getCamelContext(), "platform-http");

             
            if (config.getComponentProperties() != null && !config.getComponentProperties().isEmpty()) {
                setProperties(this, config.getComponentProperties());
            }
        } catch (IllegalArgumentException e) {
             
             
             
        }
    }

    protected void doInit() throws Exception {
        super.doInit();

        try {
            RestConfiguration config = CamelContextHelper.getRestConfiguration(getCamelContext(), "jetty");

             
            if (config.getComponentProperties() != null && !config.getComponentProperties().isEmpty()) {
                setProperties(this, config.getComponentProperties());
            }
        } catch (IllegalArgumentException e) {
             
             
             
        }
    }

    protected void doInit() throws Exception {
        super.doInit();

        try {
            RestConfiguration config = CamelContextHelper.getRestConfiguration(getCamelContext(), "platform-http");

             
            if (config.getComponentProperties() != null && !config.getComponentProperties().isEmpty()) {
                setProperties(this, config.getComponentProperties());
            }
        } catch (IllegalArgumentException e) {
             
             
             
        }
    }

    protected void doInit() throws Exception {
        super.doInit();

        try {
            RestConfiguration config = CamelContextHelper.getRestConfiguration(getCamelContext(), "netty-http");

             
            if (config.getComponentProperties() != null && !config.getComponentProperties().isEmpty()) {
                setProperties(this, config.getComponentProperties());
            }
        } catch (IllegalArgumentException e) {
             
             
             
        }
    }

    protected void doInit() throws Exception {
        super.doInit();

        try {
            RestConfiguration config = CamelContextHelper.getRestConfiguration(getCamelContext(), "servlet");

             
            if (config.getComponentProperties() != null && !config.getComponentProperties().isEmpty()) {
                setProperties(this, config.getComponentProperties());
            }
        } catch (IllegalArgumentException e) {
             
             
             
        }
    }

    protected void doInit() throws Exception {
        super.doInit();

        try {
            RestConfiguration config = CamelContextHelper.getRestConfiguration(getCamelContext(), "jetty");

             
            if (config.getComponentProperties() != null && !config.getComponentProperties().isEmpty()) {
                setProperties(this, config.getComponentProperties());
            }
        } catch (IllegalArgumentException e) {
             
             
             
        }
    }

    protected void doInit() throws Exception {
        super.doInit();

        try {
            RestConfiguration config = CamelContextHelper.getRestConfiguration(getCamelContext(), "servlet");

             
            if (config.getComponentProperties() != null && !config.getComponentProperties().isEmpty()) {
                setProperties(this, config.getComponentProperties());
            }
        } catch (IllegalArgumentException e) {
             
             
             
        }
    }

    protected void doInit() throws Exception {
        super.doInit();

        try {
            RestConfiguration config = CamelContextHelper.getRestConfiguration(getCamelContext(), "netty-http");

             
            if (config.getComponentProperties() != null && !config.getComponentProperties().isEmpty()) {
                setProperties(this, config.getComponentProperties());
            }
        } catch (IllegalArgumentException e) {
             
             
             
        }
    }

    protected void doInit() throws Exception {
        super.doInit();

        try {
            RestConfiguration config = CamelContextHelper.getRestConfiguration(getCamelContext(), "jetty");

             
            if (config.getComponentProperties() != null && !config.getComponentProperties().isEmpty()) {
                setProperties(this, config.getComponentProperties());
            }
        } catch (IllegalArgumentException e) {
             
             
             
        }
    }

    protected void doInit() throws Exception {
        super.doInit();

        try {
            RestConfiguration config = CamelContextHelper.getRestConfiguration(getCamelContext(), "netty-http");

             
            if (config.getComponentProperties() != null && !config.getComponentProperties().isEmpty()) {
                setProperties(this, config.getComponentProperties());
            }
        } catch (IllegalArgumentException e) {
             
             
             
        }
    }

    public void setPrivateKeyName(String privateKeyName) {
        if (context != null && privateKeyName != null) {
            PrivateKey pk = context.getRegistry().lookupByNameAndType(privateKeyName, PrivateKey.class);
            if (pk != null) {
                setPrivateKey(pk);
            }
        }
        if (privateKeyName != null) {
            this.privateKeyName = privateKeyName;
        }
    }

    public void setKeystoreName(String keystoreName) {
        if (context != null && keystoreName != null) {
            KeyStore keystore = context.getRegistry().lookupByNameAndType(keystoreName, KeyStore.class);
            if (keystore != null) {
                setKeystore(keystore);
            }
        }
        if (keystoreName != null) {
            this.keystoreName = keystoreName;
        }
    }

    public void setPrivateKeyName(String privateKeyName) {
        if (context != null && privateKeyName != null) {
            PrivateKey pk = context.getRegistry().lookupByNameAndType(privateKeyName, PrivateKey.class);
            if (pk != null) {
                setPrivateKey(pk);
            }
        }
        if (privateKeyName != null) {
            this.privateKeyName = privateKeyName;
        }
    }

    public void setCertificateName(String certificateName) {
        if (context != null && certificateName != null) {
            Certificate certificate = context.getRegistry().lookupByNameAndType(certificateName, Certificate.class);
            if (certificate != null) {
                setCertificate(certificate);
            }
        }
        if (certificateName != null) {
            this.certificateName = certificateName;
        }
    }

    public void setPrivateKeyName(String privateKeyName) {
        if (context != null && privateKeyName != null) {
            PrivateKey pk = context.getRegistry().lookupByNameAndType(privateKeyName, PrivateKey.class);
            if (pk != null) {
                setPrivateKey(pk);
            }
        }
        if (privateKeyName != null) {
            this.privateKeyName = privateKeyName;
        }
    }

    public void setSecureRandomName(String randomName) {
        if (context != null && randomName != null) {
            SecureRandom random = context.getRegistry().lookupByNameAndType(randomName, SecureRandom.class);
            if (keystore != null) {
                setSecureRandom(random);
            }
        }
        if (randomName != null) {
            this.secureRandomName = randomName;
        }
    }

    public void setPrivateKeyName(String privateKeyName) {
        if (context != null && privateKeyName != null) {
            PrivateKey pk = context.getRegistry().lookupByNameAndType(privateKeyName, PrivateKey.class);
            if (pk != null) {
                setPrivateKey(pk);
            }
        }
        if (privateKeyName != null) {
            this.privateKeyName = privateKeyName;
        }
    }

    public void setPublicKeyName(String publicKeyName) {
        if (context != null && publicKeyName != null) {
            PublicKey pk = context.getRegistry().lookupByNameAndType(publicKeyName, PublicKey.class);
            if (pk != null) {
                setPublicKey(pk);
            }
        }
        if (publicKeyName != null) {
            this.publicKeyName = publicKeyName;
        }
    }

    public void setKeystoreName(String keystoreName) {
        if (context != null && keystoreName != null) {
            KeyStore keystore = context.getRegistry().lookupByNameAndType(keystoreName, KeyStore.class);
            if (keystore != null) {
                setKeystore(keystore);
            }
        }
        if (keystoreName != null) {
            this.keystoreName = keystoreName;
        }
    }

    public void setCertificateName(String certificateName) {
        if (context != null && certificateName != null) {
            Certificate certificate = context.getRegistry().lookupByNameAndType(certificateName, Certificate.class);
            if (certificate != null) {
                setCertificate(certificate);
            }
        }
        if (certificateName != null) {
            this.certificateName = certificateName;
        }
    }

    public void setKeystoreName(String keystoreName) {
        if (context != null && keystoreName != null) {
            KeyStore keystore = context.getRegistry().lookupByNameAndType(keystoreName, KeyStore.class);
            if (keystore != null) {
                setKeystore(keystore);
            }
        }
        if (keystoreName != null) {
            this.keystoreName = keystoreName;
        }
    }

    public void setSecureRandomName(String randomName) {
        if (context != null && randomName != null) {
            SecureRandom random = context.getRegistry().lookupByNameAndType(randomName, SecureRandom.class);
            if (keystore != null) {
                setSecureRandom(random);
            }
        }
        if (randomName != null) {
            this.secureRandomName = randomName;
        }
    }

    public void setKeystoreName(String keystoreName) {
        if (context != null && keystoreName != null) {
            KeyStore keystore = context.getRegistry().lookupByNameAndType(keystoreName, KeyStore.class);
            if (keystore != null) {
                setKeystore(keystore);
            }
        }
        if (keystoreName != null) {
            this.keystoreName = keystoreName;
        }
    }

    public void setPublicKeyName(String publicKeyName) {
        if (context != null && publicKeyName != null) {
            PublicKey pk = context.getRegistry().lookupByNameAndType(publicKeyName, PublicKey.class);
            if (pk != null) {
                setPublicKey(pk);
            }
        }
        if (publicKeyName != null) {
            this.publicKeyName = publicKeyName;
        }
    }

    public void setCertificateName(String certificateName) {
        if (context != null && certificateName != null) {
            Certificate certificate = context.getRegistry().lookupByNameAndType(certificateName, Certificate.class);
            if (certificate != null) {
                setCertificate(certificate);
            }
        }
        if (certificateName != null) {
            this.certificateName = certificateName;
        }
    }

    public void setSecureRandomName(String randomName) {
        if (context != null && randomName != null) {
            SecureRandom random = context.getRegistry().lookupByNameAndType(randomName, SecureRandom.class);
            if (keystore != null) {
                setSecureRandom(random);
            }
        }
        if (randomName != null) {
            this.secureRandomName = randomName;
        }
    }

    public void setCertificateName(String certificateName) {
        if (context != null && certificateName != null) {
            Certificate certificate = context.getRegistry().lookupByNameAndType(certificateName, Certificate.class);
            if (certificate != null) {
                setCertificate(certificate);
            }
        }
        if (certificateName != null) {
            this.certificateName = certificateName;
        }
    }

    public void setPublicKeyName(String publicKeyName) {
        if (context != null && publicKeyName != null) {
            PublicKey pk = context.getRegistry().lookupByNameAndType(publicKeyName, PublicKey.class);
            if (pk != null) {
                setPublicKey(pk);
            }
        }
        if (publicKeyName != null) {
            this.publicKeyName = publicKeyName;
        }
    }

    public void setSecureRandomName(String randomName) {
        if (context != null && randomName != null) {
            SecureRandom random = context.getRegistry().lookupByNameAndType(randomName, SecureRandom.class);
            if (keystore != null) {
                setSecureRandom(random);
            }
        }
        if (randomName != null) {
            this.secureRandomName = randomName;
        }
    }

    public void setPublicKeyName(String publicKeyName) {
        if (context != null && publicKeyName != null) {
            PublicKey pk = context.getRegistry().lookupByNameAndType(publicKeyName, PublicKey.class);
            if (pk != null) {
                setPublicKey(pk);
            }
        }
        if (publicKeyName != null) {
            this.publicKeyName = publicKeyName;
        }
    }

    private void configureExecutorService(FaultToleranceProcessor processor, FaultToleranceConfigurationCommon config) {
        if (config.getThreadOffloadExecutorService() != null) {
            String ref = config.getThreadOffloadExecutorService();
            boolean shutdownThreadPool = false;
            ExecutorService executorService = lookupByNameAndType(ref, ExecutorService.class);
            if (executorService == null) {
                executorService = lookupExecutorServiceRef("CircuitBreaker", definition, ref);
                shutdownThreadPool = true;
            }
            processor.setExecutorService(executorService);
            processor.setShutdownExecutorService(shutdownThreadPool);
        }
    }

    private void configureTimeoutExecutorService(ResilienceProcessor processor, Resilience4jConfigurationCommon config) {
        if (!parseBoolean(config.getTimeoutEnabled(), false)) {
            return;
        }

        if (config.getTimeoutExecutorService() != null) {
            String ref = config.getTimeoutExecutorService();
            boolean shutdownThreadPool = false;
            ExecutorService executorService = lookupByNameAndType(ref, ExecutorService.class);
            if (executorService == null) {
                executorService = lookupExecutorServiceRef("CircuitBreaker", definition, ref);
                shutdownThreadPool = true;
            }
            processor.setExecutorService(executorService);
            processor.setShutdownExecutorService(shutdownThreadPool);
        }
    }

    FaultToleranceConfigurationDefinition buildFaultToleranceConfiguration() throws Exception {
        Map<String, Object> properties = new HashMap<>();

        final PropertyConfigurer configurer = PluginHelper.getConfigurerResolver(camelContext)
                .resolvePropertyConfigurer(FaultToleranceConfigurationDefinition.class.getName(), camelContext);

         
         
        loadProperties(properties, Suppliers.firstNotNull(
                () -> camelContext.getCamelContextExtension().getContextPlugin(Model.class)
                        .getFaultToleranceConfiguration(null),
                () -> lookupByNameAndType(FaultToleranceConstants.DEFAULT_FAULT_TOLERANCE_CONFIGURATION_ID,
                        FaultToleranceConfigurationDefinition.class)),
                configurer);

         
         
        if (definition.getConfiguration() != null) {
            final String ref = parseString(definition.getConfiguration());
            loadProperties(properties, Suppliers.firstNotNull(
                    () -> camelContext.getCamelContextExtension().getContextPlugin(Model.class)
                            .getFaultToleranceConfiguration(ref),
                    () -> mandatoryLookup(ref, FaultToleranceConfigurationDefinition.class)),
                    configurer);
        }

         
        loadProperties(properties, Optional.ofNullable(definition.getFaultToleranceConfiguration()), configurer);

         
        FaultToleranceConfigurationDefinition config = new FaultToleranceConfigurationDefinition();
        PropertyBindingSupport.build()
                .withCamelContext(camelContext)
                .withIgnoreCase(true)
                .withConfigurer(configurer)
                .withProperties(properties)
                .withTarget(config)
                .bind();

        return config;
    }

    Resilience4jConfigurationDefinition buildResilience4jConfiguration() throws Exception {
        Map<String, Object> properties = new HashMap<>();

        final PropertyConfigurer configurer = PluginHelper.getConfigurerResolver(camelContext)
                .resolvePropertyConfigurer(Resilience4jConfigurationDefinition.class.getName(), camelContext);

         
         
        loadProperties(properties, Suppliers.firstNotNull(
                () -> camelContext.getCamelContextExtension().getContextPlugin(Model.class).getResilience4jConfiguration(null),
                () -> lookupByNameAndType(ResilienceConstants.DEFAULT_RESILIENCE_CONFIGURATION_ID,
                        Resilience4jConfigurationDefinition.class)),
                configurer);

         
         
        if (definition.getConfiguration() != null) {
            final String ref = parseString(definition.getConfiguration());
            loadProperties(properties, Suppliers.firstNotNull(
                    () -> camelContext.getCamelContextExtension().getContextPlugin(Model.class)
                            .getResilience4jConfiguration(ref),
                    () -> mandatoryLookup(ref, Resilience4jConfigurationDefinition.class)),
                    configurer);
        }

         
        loadProperties(properties, Optional.ofNullable(definition.getResilience4jConfiguration()), configurer);

         
        Resilience4jConfigurationDefinition config = new Resilience4jConfigurationDefinition();
        PropertyBindingSupport.build()
                .withCamelContext(camelContext)
                .withIgnoreCase(true)
                .withConfigurer(configurer)
                .withProperties(properties)
                .withTarget(config)
                .bind();

        return config;
    }

    private void loadProperties(Map<String, Object> properties, Optional<?> optional, PropertyConfigurer configurer) {
        BeanIntrospection beanIntrospection = PluginHelper.getBeanIntrospection(camelContext);
        optional.ifPresent(bean -> {
            if (configurer instanceof ExtendedPropertyConfigurerGetter) {
                ExtendedPropertyConfigurerGetter getter = (ExtendedPropertyConfigurerGetter) configurer;
                Map<String, Object> types = getter.getAllOptions(bean);
                types.forEach((k, t) -> {
                    Object value = getter.getOptionValue(bean, k, true);
                    if (value != null) {
                        properties.put(k, value);
                    }
                });
            } else {
                 
                beanIntrospection.getProperties(bean, properties, null, false);
            }
        });
    }

    private void loadProperties(Map<String, Object> properties, Optional<?> optional, PropertyConfigurer configurer) {
        BeanIntrospection beanIntrospection = PluginHelper.getBeanIntrospection(camelContext);
        optional.ifPresent(bean -> {
            if (configurer instanceof ExtendedPropertyConfigurerGetter) {
                ExtendedPropertyConfigurerGetter getter = (ExtendedPropertyConfigurerGetter) configurer;
                Map<String, Object> types = getter.getAllOptions(bean);
                types.forEach((k, t) -> {
                    Object value = getter.getOptionValue(bean, k, true);
                    if (value != null) {
                        properties.put(k, value);
                    }
                });
            } else {
                 
                beanIntrospection.getProperties(bean, properties, null, false);
            }
        });
    }

    protected JsonObject doCallJson(Map<String, Object> options) {
        JsonObject root = new JsonObject();

        List<FaultToleranceProcessor> cbs = new ArrayList<>();
        for (Route route : getCamelContext().getRoutes()) {
            List<Processor> list = route.filter("*");
            for (Processor p : list) {
                if (p instanceof FaultToleranceProcessor) {
                    cbs.add((FaultToleranceProcessor) p);
                }
            }
        }
         
        cbs.sort(Comparator.comparing(FaultToleranceProcessor::getId));

        final List<JsonObject> list = new ArrayList<>();
        for (FaultToleranceProcessor cb : cbs) {
            JsonObject jo = new JsonObject();
            jo.put("id", cb.getId());
            jo.put("routeId", cb.getRouteId());
            jo.put("state", cb.getCircuitBreakerState());
            list.add(jo);
        }
        root.put("circuitBreakers", list);

        return root;
    }

    protected JsonObject doCallJson(Map<String, Object> options) {
        JsonObject root = new JsonObject();

        List<ResilienceProcessor> cbs = new ArrayList<>();
        for (Route route : getCamelContext().getRoutes()) {
            List<Processor> list = route.filter("*");
            for (Processor p : list) {
                if (p instanceof ResilienceProcessor) {
                    cbs.add((ResilienceProcessor) p);
                }
            }
        }
         
        cbs.sort(Comparator.comparing(ResilienceProcessor::getId));

        final List<JsonObject> list = new ArrayList<>();
        for (ResilienceProcessor cb : cbs) {
            JsonObject jo = new JsonObject();
            jo.put("id", cb.getId());
            jo.put("routeId", cb.getRouteId());
            jo.put("state", cb.getCircuitBreakerState());
            jo.put("bufferedCalls", cb.getNumberOfBufferedCalls());
            jo.put("successfulCalls", cb.getNumberOfSuccessfulCalls());
            jo.put("failedCalls", cb.getNumberOfFailedCalls());
            jo.put("notPermittedCalls", cb.getNumberOfNotPermittedCalls());
            jo.put("failureRate", cb.getFailureRate());
            list.add(jo);
        }
        root.put("circuitBreakers", list);

        return root;
    }

    public List<Processor> next() {
        if (!hasNext()) {
            return null;
        }
        List<Processor> answer = new ArrayList<>();
        answer.add(processor);
        if (fallbackProcessor != null) {
            answer.add(fallbackProcessor);
        }
        return answer;
    }

    public List<Processor> next() {
        if (!hasNext()) {
            return null;
        }
        List<Processor> answer = new ArrayList<>();
        if (len > 0) {
            answer.addAll(Arrays.asList(filters));
        }
        if (otherwise != null) {
            answer.add(otherwise);
        }
        return answer;
    }

    public List<Processor> next() {
        if (!hasNext()) {
            return null;
        }
        List<Processor> answer = new ArrayList<>();
        answer.add(processor);
        if (fallbackProcessor != null) {
            answer.add(fallbackProcessor);
        }
        return answer;
    }

    public List<Processor> next() {
        if (!hasNext()) {
            return null;
        }
        List<Processor> answer = new ArrayList<>();
        if (tryProcessor != null) {
            answer.add(tryProcessor);
        }
        if (catchClauses != null && !catchClauses.isEmpty()) {
            answer.addAll(catchClauses);
        }
        if (finallyProcessor != null) {
            answer.add(finallyProcessor);
        }
        return answer;
    }

    public List<Processor> next() {
        if (!hasNext()) {
            return null;
        }
        List<Processor> answer = new ArrayList<>();
        if (len > 0) {
            answer.addAll(Arrays.asList(filters));
        }
        if (otherwise != null) {
            answer.add(otherwise);
        }
        return answer;
    }

    public List<Processor> next() {
        if (!hasNext()) {
            return null;
        }
        List<Processor> answer = new ArrayList<>();
        if (tryProcessor != null) {
            answer.add(tryProcessor);
        }
        if (catchClauses != null && !catchClauses.isEmpty()) {
            answer.addAll(catchClauses);
        }
        if (finallyProcessor != null) {
            answer.add(finallyProcessor);
        }
        return answer;
    }

    public boolean startInterrogation(ASDUAddress asduAddress, short qoi) {
        DataModuleContext context = dataModuleContextRef.get();
        if (context == null) {
            LOG.warn("Cannot start interrogation: not connected or data module not initialized");
            return false;
        }
        try {
            context.startInterrogation(asduAddress, qoi);
            LOG.debug("Started interrogation for ASDU address {} with QOI {}", asduAddress, qoi);
            return true;
        } catch (Exception e) {
            LOG.error("Failed to start interrogation", e);
            return false;
        }
    }

    public boolean readValue(ASDUAddress asduAddress, InformationObjectAddress ioa) {
        DataModuleContext context = dataModuleContextRef.get();
        if (context == null) {
            LOG.warn("Cannot send read command: not connected or data module not initialized");
            return false;
        }
        try {
            ASDUHeader header = new ASDUHeader(
                    new CauseOfTransmission(StandardCause.REQUEST),
                    asduAddress);
            ReadCommand readCommand = new ReadCommand(header, ioa);

            client.writeCommand(readCommand);

            LOG.debug("Sent read command for ASDU address {} IOA {}", asduAddress, ioa);
            return true;
        } catch (Exception e) {
            LOG.error("Failed to send read command", e);
            return false;
        }
    }

    protected void setup() {
        execution = getSalesforceExecution();

        execution.setClientId(clientId);
        execution.setClientSecret(clientSecret);
        execution.setHttpClientProperties(httpClientProperties);
        execution.setHttpProxyAuthUri(httpProxyAuthUri);
        execution.setHttpProxyHost(httpProxyHost);
        execution.setHttpProxyPort(httpProxyPort);
        execution.setHttpProxyRealm(httpProxyRealm);
        execution.setHttpProxyUsername(httpProxyUsername);
        execution.setHttpProxyPassword(httpProxyPassword);
        execution.setHttpProxyExcludedAddresses(httpProxyExcludedAddresses);
        execution.setHttpProxyIncludedAddresses(httpProxyIncludedAddresses);
        execution.setHttpProxySocks4(isHttpProxySocks4);
        execution.setHttpProxySecure(isHttpProxySecure);
        execution.setHttpProxyUseDigestAuth(httpProxyUseDigestAuth);
        execution.setLoginUrl(loginUrl);
        execution.setUserName(userName);
        execution.setPassword(password);
        execution.setVersion(version);
        execution.setSslContextParameters(sslContextParameters);
        execution.setJwtAudience(jwtAudience);
        execution.setKeyStoreParameters(generateKeyStoreParameters());
    }

    public Container build() {
        Container container = new Container();
        container.setAllowPrivilegeEscalation(allowPrivilegeEscalation);
        container.setAuto(auto);
        container.setCapabilitiesAdd(capabilitiesAdd);
        container.setCapabilitiesDrop(capabilitiesDrop);
        container.setEnabled(enabled);
        container.setExpose(expose);
        container.setImage(image);
        container.setImagePullPolicy(imagePullPolicy);
        container.setImagePullSecrets(imagePullSecrets);
        container.setLimitCPU(limitCPU);
        container.setLimitMemory(limitMemory);
        container.setName(name);
        container.setPort(port);
        container.setPortName(portName);
        container.setRequestCPU(requestCPU);
        container.setRequestMemory(requestMemory);
        container.setRunAsNonRoot(runAsNonRoot);
        container.setRunAsUser(runAsUser);
        container.setSeccompProfileType(seccompProfileType);
        container.setServicePort(servicePort);
        container.setServicePortName(servicePortName);
        return container;
    }

    private boolean isBulkV2Operation(OperationName operationName) {
        switch (operationName) {
            case BULK2_CREATE_JOB:
            case BULK2_CREATE_BATCH:
            case BULK2_CLOSE_JOB:
            case BULK2_GET_JOB:
            case BULK2_ABORT_JOB:
            case BULK2_DELETE_JOB:
            case BULK2_GET_SUCCESSFUL_RESULTS:
            case BULK2_GET_FAILED_RESULTS:
            case BULK2_GET_UNPROCESSED_RECORDS:
            case BULK2_GET_ALL_JOBS:
            case BULK2_CREATE_QUERY_JOB:
            case BULK2_GET_QUERY_JOB:
            case BULK2_GET_QUERY_JOB_RESULTS:
            case BULK2_ABORT_QUERY_JOB:
            case BULK2_DELETE_QUERY_JOB:
            case BULK2_GET_ALL_QUERY_JOBS:
                return true;
            default:
                return false;
        }
    }

    private static boolean isBulkOperation(OperationName operationName) {
        switch (operationName) {
            case CREATE_JOB:
            case GET_JOB:
            case CLOSE_JOB:
            case ABORT_JOB:
            case CREATE_BATCH:
            case GET_BATCH:
            case GET_ALL_BATCHES:
            case GET_REQUEST:
            case GET_RESULTS:
            case CREATE_BATCH_QUERY:
            case GET_QUERY_RESULT_IDS:
            case GET_QUERY_RESULT:
                return true;
            default:
                return false;
        }
    }

    private static boolean isAnalyticsOperation(OperationName operationName) {
        switch (operationName) {
            case GET_RECENT_REPORTS:
            case GET_REPORT_DESCRIPTION:
            case EXECUTE_SYNCREPORT:
            case EXECUTE_ASYNCREPORT:
            case GET_REPORT_INSTANCES:
            case GET_REPORT_RESULTS:
                return true;
            default:
                return false;
        }
    }

    private static boolean isCompositeOperation(OperationName operationName) {
        switch (operationName) {
            case COMPOSITE:
            case COMPOSITE_BATCH:
            case COMPOSITE_TREE:
                return true;
            default:
                return false;
        }
    }

    private static boolean isAnalyticsOperation(OperationName operationName) {
        switch (operationName) {
            case GET_RECENT_REPORTS:
            case GET_REPORT_DESCRIPTION:
            case EXECUTE_SYNCREPORT:
            case EXECUTE_ASYNCREPORT:
            case GET_REPORT_INSTANCES:
            case GET_REPORT_RESULTS:
                return true;
            default:
                return false;
        }
    }

    private static boolean isJobOperation(OperationName operationName) {
        switch (operationName) {
            case COMPLETE_JOB:
            case FAIL_JOB:
            case UPDATE_JOB_RETRIES:
            case THROW_ERROR:
                return true;
            default:
                return false;
        }
    }

    private static boolean isAnalyticsOperation(OperationName operationName) {
        switch (operationName) {
            case GET_RECENT_REPORTS:
            case GET_REPORT_DESCRIPTION:
            case EXECUTE_SYNCREPORT:
            case EXECUTE_ASYNCREPORT:
            case GET_REPORT_INSTANCES:
            case GET_REPORT_RESULTS:
                return true;
            default:
                return false;
        }
    }

    private static boolean isCompositeSObjectCollectionsOperation(OperationName operationName) {
        switch (operationName) {
            case COMPOSITE_CREATE_SOBJECT_COLLECTIONS:
            case COMPOSITE_UPDATE_SOBJECT_COLLECTIONS:
            case COMPOSITE_UPSERT_SOBJECT_COLLECTIONS:
            case COMPOSITE_RETRIEVE_SOBJECT_COLLECTIONS:
            case COMPOSITE_DELETE_SOBJECT_COLLECTIONS:
                return true;
            default:
                return false;
        }
    }

    private static boolean isCompositeOperation(OperationName operationName) {
        switch (operationName) {
            case COMPOSITE:
            case COMPOSITE_BATCH:
            case COMPOSITE_TREE:
                return true;
            default:
                return false;
        }
    }

    private static boolean isJobOperation(OperationName operationName) {
        switch (operationName) {
            case COMPLETE_JOB:
            case FAIL_JOB:
            case UPDATE_JOB_RETRIES:
            case THROW_ERROR:
                return true;
            default:
                return false;
        }
    }

    private static boolean isCompositeOperation(OperationName operationName) {
        switch (operationName) {
            case COMPOSITE:
            case COMPOSITE_BATCH:
            case COMPOSITE_TREE:
                return true;
            default:
                return false;
        }
    }

    private static boolean isCompositeSObjectCollectionsOperation(OperationName operationName) {
        switch (operationName) {
            case COMPOSITE_CREATE_SOBJECT_COLLECTIONS:
            case COMPOSITE_UPDATE_SOBJECT_COLLECTIONS:
            case COMPOSITE_UPSERT_SOBJECT_COLLECTIONS:
            case COMPOSITE_RETRIEVE_SOBJECT_COLLECTIONS:
            case COMPOSITE_DELETE_SOBJECT_COLLECTIONS:
                return true;
            default:
                return false;
        }
    }

    private static boolean isJobOperation(OperationName operationName) {
        switch (operationName) {
            case COMPLETE_JOB:
            case FAIL_JOB:
            case UPDATE_JOB_RETRIES:
            case THROW_ERROR:
                return true;
            default:
                return false;
        }
    }

    private static boolean isCompositeSObjectCollectionsOperation(OperationName operationName) {
        switch (operationName) {
            case COMPOSITE_CREATE_SOBJECT_COLLECTIONS:
            case COMPOSITE_UPDATE_SOBJECT_COLLECTIONS:
            case COMPOSITE_UPSERT_SOBJECT_COLLECTIONS:
            case COMPOSITE_RETRIEVE_SOBJECT_COLLECTIONS:
            case COMPOSITE_DELETE_SOBJECT_COLLECTIONS:
                return true;
            default:
                return false;
        }
    }

    private MessageListener createHandshakeListener() {
        return (channel, message) -> component.getHttpClient().getWorkerPool().execute(() -> {
            LOG.debug("[CHANNEL:META_HANDSHAKE]: {}", message);

            if (!message.isSuccessful()) {
                LOG.warn("Handshake failure: {}", message);
                handshakeError = (String) message.get(ERROR_FIELD);
                handshakeException = getFailure(message);
                if (handshakeError != null) {
                    if (handshakeError.startsWith("403::")) {
                        String failureReason = getFailureReason(message);
                        if (failureReason.equals(AUTHENTICATION_INVALID)) {
                            LOG.debug(
                                    "attempting login due to handshake error: 403 -> 401::Authentication invalid");
                            session.attemptLoginUntilSuccessful(backoffIncrement, maxBackoff);
                        }
                    }
                }
                 
                LOG.debug("Handshake failed, so try again.");
                client.handshake();
            } else if (!channelToConsumers.isEmpty()) {
                channelsToSubscribe.clear();
                channelsToSubscribe.addAll(channelToConsumers.keySet());
                LOG.info("Handshake successful. Channels to subscribe: {}", channelsToSubscribe);
            }
        });
    }

    private MessageListener createConnectionListener() {
        return (channel, message) -> component.getHttpClient().getWorkerPool().execute(() -> {
            LOG.debug("[CHANNEL:META_CONNECT]: {}", message);

            if (!message.isSuccessful()) {
                LOG.warn("Connect failure: {}", message);
                connectError = (String) message.get(ERROR_FIELD);
                connectException = getFailure(message);

                if (connectError != null && connectError.equals(AUTHENTICATION_INVALID)) {
                    LOG.debug("connectError: {}", connectError);
                    LOG.debug("Attempting login...");
                    session.attemptLoginUntilSuccessful(backoffIncrement, maxBackoff);
                }
                if (message.getAdvice() == null || "none".equals(message.getAdvice().get("reconnect"))) {
                    LOG.debug("Advice == none, so handshaking");
                    client.handshake();
                }
            } else if (!channelsToSubscribe.isEmpty()) {
                LOG.info("Subscribing to channels: {}", channelsToSubscribe);
                for (var channelName : channelsToSubscribe) {
                    for (var consumer : channelToConsumers.get(channelName)) {
                        subscribe(consumer);
                    }
                }
            }
        });
    }

    public void getRecentReports(final Map<String, List<String>> headers, final RecentReportsResponseCallback callback) {
        final Request request = getRequest(HttpMethod.GET, reportsUrl(), headers);

        doHttpRequest(request, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                List<RecentReport> recentReports = null;
                if (response != null) {
                    try {
                        recentReports = unmarshalResponse(response, request, TypeReferences.RECENT_REPORT_LIST_TYPE);
                    } catch (SalesforceException e) {
                        ex = e;
                    }
                }
                callback.onResponse(recentReports, headers, ex);
            }
        });
    }

    public void getReportInstances(
            String reportId, final Map<String, List<String>> headers, final ReportInstanceListResponseCallback callback) {

        final Request request = getRequest(HttpMethod.GET, reportInstancesUrl(reportId), headers);

        doHttpRequest(request, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                List<ReportInstance> reportInstances = null;
                if (response != null) {
                    try {
                        reportInstances = unmarshalResponse(response, request, TypeReferences.REPORT_INSTANCE_LIST_TYPE);
                    } catch (SalesforceException e) {
                        ex = e;
                    }
                }
                callback.onResponse(reportInstances, headers, ex);
            }
        });
    }

    public void getRecentReports(final Map<String, List<String>> headers, final RecentReportsResponseCallback callback) {
        final Request request = getRequest(HttpMethod.GET, reportsUrl(), headers);

        doHttpRequest(request, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                List<RecentReport> recentReports = null;
                if (response != null) {
                    try {
                        recentReports = unmarshalResponse(response, request, TypeReferences.RECENT_REPORT_LIST_TYPE);
                    } catch (SalesforceException e) {
                        ex = e;
                    }
                }
                callback.onResponse(recentReports, headers, ex);
            }
        });
    }

    public void getReportDescription(
            String reportId, final Map<String, List<String>> headers, final ReportDescriptionResponseCallback callback) {

        final Request request = getRequest(HttpMethod.GET, reportsDescribeUrl(reportId), headers);

        doHttpRequest(request, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                ReportDescription reportDescription = null;
                try {
                    reportDescription = unmarshalResponse(response, request, ReportDescription.class);
                } catch (SalesforceException e) {
                    ex = e;
                }
                callback.onResponse(reportDescription, headers, ex);
            }
        });
    }

    public void getRecentReports(final Map<String, List<String>> headers, final RecentReportsResponseCallback callback) {
        final Request request = getRequest(HttpMethod.GET, reportsUrl(), headers);

        doHttpRequest(request, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                List<RecentReport> recentReports = null;
                if (response != null) {
                    try {
                        recentReports = unmarshalResponse(response, request, TypeReferences.RECENT_REPORT_LIST_TYPE);
                    } catch (SalesforceException e) {
                        ex = e;
                    }
                }
                callback.onResponse(recentReports, headers, ex);
            }
        });
    }

    public void getBatch(
            String jobId, String batchId, Map<String, List<String>> headers, final BatchInfoResponseCallback callback) {
        final Request get = getRequest(HttpMethod.GET, batchUrl(jobId, batchId), headers);

         
        doHttpRequest(get, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                BatchInfo value = null;
                try {
                    value = unmarshalResponse(response, get, BatchInfo.class);
                } catch (SalesforceException e) {
                    ex = e;
                }
                callback.onResponse(value, headers, ex);
            }
        });
    }

    public void getRecentReports(final Map<String, List<String>> headers, final RecentReportsResponseCallback callback) {
        final Request request = getRequest(HttpMethod.GET, reportsUrl(), headers);

        doHttpRequest(request, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                List<RecentReport> recentReports = null;
                if (response != null) {
                    try {
                        recentReports = unmarshalResponse(response, request, TypeReferences.RECENT_REPORT_LIST_TYPE);
                    } catch (SalesforceException e) {
                        ex = e;
                    }
                }
                callback.onResponse(recentReports, headers, ex);
            }
        });
    }

    public void getAllBatches(String jobId, Map<String, List<String>> headers, final BatchInfoListResponseCallback callback) {
        final Request get = getRequest(HttpMethod.GET, batchUrl(jobId, null), headers);

         
        doHttpRequest(get, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                BatchInfoList value = null;
                try {
                    value = unmarshalResponse(response, get, BatchInfoList.class);
                } catch (SalesforceException e) {
                    ex = e;
                }
                callback.onResponse(value != null ? value.getBatchInfo() : null, headers, ex);
            }
        });
    }

    public void getRecentReports(final Map<String, List<String>> headers, final RecentReportsResponseCallback callback) {
        final Request request = getRequest(HttpMethod.GET, reportsUrl(), headers);

        doHttpRequest(request, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                List<RecentReport> recentReports = null;
                if (response != null) {
                    try {
                        recentReports = unmarshalResponse(response, request, TypeReferences.RECENT_REPORT_LIST_TYPE);
                    } catch (SalesforceException e) {
                        ex = e;
                    }
                }
                callback.onResponse(recentReports, headers, ex);
            }
        });
    }

    public void getQueryResultIds(
            String jobId, String batchId, Map<String, List<String>> headers, final QueryResultIdsCallback callback) {
        final Request get = getRequest(HttpMethod.GET, batchResultUrl(jobId, batchId, null), headers);

         
        doHttpRequest(get, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                QueryResultList value = null;
                try {
                    value = unmarshalResponse(response, get, QueryResultList.class);
                } catch (SalesforceException e) {
                    ex = e;
                }
                callback.onResponse(value != null ? Collections.unmodifiableList(value.getResult()) : null, headers, ex);
            }
        });
    }